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

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

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

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

> source("incl/start.R")
[17:28:16.911] plan(): Setting new future strategy stack:
[17:28:16.913] List of future strategies:
[17:28:16.913] 1. sequential:
[17:28:16.913]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:16.913]    - tweaked: FALSE
[17:28:16.913]    - call: future::plan("sequential")
[17:28:16.929] plan(): nbrOfWorkers() = 1
> 
> message("*** rng ...")
*** rng ...
> 
> okind <- RNGkind()
> 
> ## A valid regular seed
> f <- Future(42, seed = 42L)
[17:28:16.936] getGlobalsAndPackages() ...
[17:28:16.936] 
[17:28:16.937] - globals: [0] <none>
[17:28:16.937] 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: db266b67-3375-aea4-18cf-ad3ddc692f7c
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:28:16.938] getGlobalsAndPackages() ...
[17:28:16.938] 
[17:28:16.938] - globals: [0] <none>
[17:28:16.939] 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: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'Future', 'environment'
> stopifnot(identical(RNGkind(), okind))
> 
> f <- Future(42, seed = TRUE)
[17:28:16.939] getGlobalsAndPackages() ...
[17:28:16.939] 
[17:28:16.940] - globals: [0] <none>
[17:28:16.940] 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, -1142100680, -1934721455, -2044651370, -2140575105, -709333892, 1019429238)
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'Future', 'environment'
> stopifnot(identical(RNGkind(), okind))
> 
> f <- Future(42, seed = FALSE)
[17:28:16.940] getGlobalsAndPackages() ...
[17:28:16.941] 
[17:28:16.941] - globals: [0] <none>
[17:28:16.941] 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: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'Future', 'environment'
> stopifnot(identical(RNGkind(), okind))
> 
> f <- Future(42, seed = NULL)
[17:28:16.942] getGlobalsAndPackages() ...
[17:28:16.942] 
[17:28:16.942] - globals: [0] <none>
[17:28:16.942] 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: db266b67-3375-aea4-18cf-ad3ddc692f7c
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:28:16.949] plan(): Setting new future strategy stack:
[17:28:16.950] List of future strategies:
[17:28:16.950] 1. sequential:
[17:28:16.950]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:16.950]    - tweaked: FALSE
[17:28:16.950]    - call: plan("sequential")
[17:28:16.964] plan(): nbrOfWorkers() = 1
> y0 <- fsample(0:3, seed = 42L)
[17:28:16.989] getGlobalsAndPackages() ...
[17:28:16.989] Searching for globals...
[17:28:16.996] - globals found: [3] '{', 'sample', 'x'
[17:28:16.996] Searching for globals ... DONE
[17:28:16.996] Resolving globals: FALSE
[17:28:16.998] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:16.998] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:16.998] - globals: [1] 'x'
[17:28:16.999] 
[17:28:16.999] getGlobalsAndPackages() ... DONE
[17:28:16.999] run() for 'Future' ...
[17:28:17.000] - state: 'created'
[17:28:17.000] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.000] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.001] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.001]   - Field: 'label'
[17:28:17.001]   - Field: 'local'
[17:28:17.001]   - Field: 'owner'
[17:28:17.001]   - Field: 'envir'
[17:28:17.001]   - Field: 'packages'
[17:28:17.002]   - Field: 'gc'
[17:28:17.002]   - Field: 'conditions'
[17:28:17.002]   - Field: 'expr'
[17:28:17.002]   - Field: 'uuid'
[17:28:17.002]   - Field: 'seed'
[17:28:17.002]   - Field: 'version'
[17:28:17.003]   - Field: 'result'
[17:28:17.003]   - Field: 'asynchronous'
[17:28:17.003]   - Field: 'calls'
[17:28:17.003]   - Field: 'globals'
[17:28:17.003]   - Field: 'stdout'
[17:28:17.003]   - Field: 'earlySignal'
[17:28:17.004]   - Field: 'lazy'
[17:28:17.004]   - Field: 'state'
[17:28:17.004] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.004] - Launch lazy future ...
[17:28:17.005] Packages needed by the future expression (n = 0): <none>
[17:28:17.005] Packages needed by future strategies (n = 0): <none>
[17:28:17.006] {
[17:28:17.006]     {
[17:28:17.006]         {
[17:28:17.006]             ...future.startTime <- base::Sys.time()
[17:28:17.006]             {
[17:28:17.006]                 {
[17:28:17.006]                   {
[17:28:17.006]                     {
[17:28:17.006]                       base::local({
[17:28:17.006]                         has_future <- base::requireNamespace("future", 
[17:28:17.006]                           quietly = TRUE)
[17:28:17.006]                         if (has_future) {
[17:28:17.006]                           ns <- base::getNamespace("future")
[17:28:17.006]                           version <- ns[[".package"]][["version"]]
[17:28:17.006]                           if (is.null(version)) 
[17:28:17.006]                             version <- utils::packageVersion("future")
[17:28:17.006]                         }
[17:28:17.006]                         else {
[17:28:17.006]                           version <- NULL
[17:28:17.006]                         }
[17:28:17.006]                         if (!has_future || version < "1.8.0") {
[17:28:17.006]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.006]                             "", base::R.version$version.string), 
[17:28:17.006]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:17.006]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.006]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.006]                               "release", "version")], collapse = " "), 
[17:28:17.006]                             hostname = base::Sys.info()[["nodename"]])
[17:28:17.006]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.006]                             info)
[17:28:17.006]                           info <- base::paste(info, collapse = "; ")
[17:28:17.006]                           if (!has_future) {
[17:28:17.006]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.006]                               info)
[17:28:17.006]                           }
[17:28:17.006]                           else {
[17:28:17.006]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.006]                               info, version)
[17:28:17.006]                           }
[17:28:17.006]                           base::stop(msg)
[17:28:17.006]                         }
[17:28:17.006]                       })
[17:28:17.006]                     }
[17:28:17.006]                     ...future.strategy.old <- future::plan("list")
[17:28:17.006]                     options(future.plan = NULL)
[17:28:17.006]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.006]                     future::plan("default", .cleanup = FALSE, 
[17:28:17.006]                       .init = FALSE)
[17:28:17.006]                   }
[17:28:17.006]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:28:17.006]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:28:17.006]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:28:17.006]                 }
[17:28:17.006]                 ...future.workdir <- getwd()
[17:28:17.006]             }
[17:28:17.006]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.006]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.006]         }
[17:28:17.006]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.006]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.006]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.006]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.006]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.006]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.006]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.006]             base::names(...future.oldOptions))
[17:28:17.006]     }
[17:28:17.006]     if (FALSE) {
[17:28:17.006]     }
[17:28:17.006]     else {
[17:28:17.006]         if (TRUE) {
[17:28:17.006]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.006]                 open = "w")
[17:28:17.006]         }
[17:28:17.006]         else {
[17:28:17.006]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.006]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.006]         }
[17:28:17.006]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.006]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.006]             base::sink(type = "output", split = FALSE)
[17:28:17.006]             base::close(...future.stdout)
[17:28:17.006]         }, add = TRUE)
[17:28:17.006]     }
[17:28:17.006]     ...future.frame <- base::sys.nframe()
[17:28:17.006]     ...future.conditions <- base::list()
[17:28:17.006]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.006]     if (FALSE) {
[17:28:17.006]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.006]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.006]     }
[17:28:17.006]     ...future.result <- base::tryCatch({
[17:28:17.006]         base::withCallingHandlers({
[17:28:17.006]             ...future.value <- base::withVisible(base::local({
[17:28:17.006]                 sample(x, size = 1L)
[17:28:17.006]             }))
[17:28:17.006]             future::FutureResult(value = ...future.value$value, 
[17:28:17.006]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.006]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.006]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.006]                     ...future.globalenv.names))
[17:28:17.006]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.006]         }, condition = base::local({
[17:28:17.006]             c <- base::c
[17:28:17.006]             inherits <- base::inherits
[17:28:17.006]             invokeRestart <- base::invokeRestart
[17:28:17.006]             length <- base::length
[17:28:17.006]             list <- base::list
[17:28:17.006]             seq.int <- base::seq.int
[17:28:17.006]             signalCondition <- base::signalCondition
[17:28:17.006]             sys.calls <- base::sys.calls
[17:28:17.006]             `[[` <- base::`[[`
[17:28:17.006]             `+` <- base::`+`
[17:28:17.006]             `<<-` <- base::`<<-`
[17:28:17.006]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.006]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.006]                   3L)]
[17:28:17.006]             }
[17:28:17.006]             function(cond) {
[17:28:17.006]                 is_error <- inherits(cond, "error")
[17:28:17.006]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.006]                   NULL)
[17:28:17.006]                 if (is_error) {
[17:28:17.006]                   sessionInformation <- function() {
[17:28:17.006]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.006]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.006]                       search = base::search(), system = base::Sys.info())
[17:28:17.006]                   }
[17:28:17.006]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.006]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.006]                     cond$call), session = sessionInformation(), 
[17:28:17.006]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.006]                   signalCondition(cond)
[17:28:17.006]                 }
[17:28:17.006]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.006]                 "immediateCondition"))) {
[17:28:17.006]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.006]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.006]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.006]                   if (TRUE && !signal) {
[17:28:17.006]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.006]                     {
[17:28:17.006]                       inherits <- base::inherits
[17:28:17.006]                       invokeRestart <- base::invokeRestart
[17:28:17.006]                       is.null <- base::is.null
[17:28:17.006]                       muffled <- FALSE
[17:28:17.006]                       if (inherits(cond, "message")) {
[17:28:17.006]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.006]                         if (muffled) 
[17:28:17.006]                           invokeRestart("muffleMessage")
[17:28:17.006]                       }
[17:28:17.006]                       else if (inherits(cond, "warning")) {
[17:28:17.006]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.006]                         if (muffled) 
[17:28:17.006]                           invokeRestart("muffleWarning")
[17:28:17.006]                       }
[17:28:17.006]                       else if (inherits(cond, "condition")) {
[17:28:17.006]                         if (!is.null(pattern)) {
[17:28:17.006]                           computeRestarts <- base::computeRestarts
[17:28:17.006]                           grepl <- base::grepl
[17:28:17.006]                           restarts <- computeRestarts(cond)
[17:28:17.006]                           for (restart in restarts) {
[17:28:17.006]                             name <- restart$name
[17:28:17.006]                             if (is.null(name)) 
[17:28:17.006]                               next
[17:28:17.006]                             if (!grepl(pattern, name)) 
[17:28:17.006]                               next
[17:28:17.006]                             invokeRestart(restart)
[17:28:17.006]                             muffled <- TRUE
[17:28:17.006]                             break
[17:28:17.006]                           }
[17:28:17.006]                         }
[17:28:17.006]                       }
[17:28:17.006]                       invisible(muffled)
[17:28:17.006]                     }
[17:28:17.006]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.006]                   }
[17:28:17.006]                 }
[17:28:17.006]                 else {
[17:28:17.006]                   if (TRUE) {
[17:28:17.006]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.006]                     {
[17:28:17.006]                       inherits <- base::inherits
[17:28:17.006]                       invokeRestart <- base::invokeRestart
[17:28:17.006]                       is.null <- base::is.null
[17:28:17.006]                       muffled <- FALSE
[17:28:17.006]                       if (inherits(cond, "message")) {
[17:28:17.006]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.006]                         if (muffled) 
[17:28:17.006]                           invokeRestart("muffleMessage")
[17:28:17.006]                       }
[17:28:17.006]                       else if (inherits(cond, "warning")) {
[17:28:17.006]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.006]                         if (muffled) 
[17:28:17.006]                           invokeRestart("muffleWarning")
[17:28:17.006]                       }
[17:28:17.006]                       else if (inherits(cond, "condition")) {
[17:28:17.006]                         if (!is.null(pattern)) {
[17:28:17.006]                           computeRestarts <- base::computeRestarts
[17:28:17.006]                           grepl <- base::grepl
[17:28:17.006]                           restarts <- computeRestarts(cond)
[17:28:17.006]                           for (restart in restarts) {
[17:28:17.006]                             name <- restart$name
[17:28:17.006]                             if (is.null(name)) 
[17:28:17.006]                               next
[17:28:17.006]                             if (!grepl(pattern, name)) 
[17:28:17.006]                               next
[17:28:17.006]                             invokeRestart(restart)
[17:28:17.006]                             muffled <- TRUE
[17:28:17.006]                             break
[17:28:17.006]                           }
[17:28:17.006]                         }
[17:28:17.006]                       }
[17:28:17.006]                       invisible(muffled)
[17:28:17.006]                     }
[17:28:17.006]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.006]                   }
[17:28:17.006]                 }
[17:28:17.006]             }
[17:28:17.006]         }))
[17:28:17.006]     }, error = function(ex) {
[17:28:17.006]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.006]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.006]                 ...future.rng), started = ...future.startTime, 
[17:28:17.006]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.006]             version = "1.8"), class = "FutureResult")
[17:28:17.006]     }, finally = {
[17:28:17.006]         if (!identical(...future.workdir, getwd())) 
[17:28:17.006]             setwd(...future.workdir)
[17:28:17.006]         {
[17:28:17.006]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.006]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.006]             }
[17:28:17.006]             base::options(...future.oldOptions)
[17:28:17.006]             if (.Platform$OS.type == "windows") {
[17:28:17.006]                 old_names <- names(...future.oldEnvVars)
[17:28:17.006]                 envs <- base::Sys.getenv()
[17:28:17.006]                 names <- names(envs)
[17:28:17.006]                 common <- intersect(names, old_names)
[17:28:17.006]                 added <- setdiff(names, old_names)
[17:28:17.006]                 removed <- setdiff(old_names, names)
[17:28:17.006]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.006]                   envs[common]]
[17:28:17.006]                 NAMES <- toupper(changed)
[17:28:17.006]                 args <- list()
[17:28:17.006]                 for (kk in seq_along(NAMES)) {
[17:28:17.006]                   name <- changed[[kk]]
[17:28:17.006]                   NAME <- NAMES[[kk]]
[17:28:17.006]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.006]                     next
[17:28:17.006]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.006]                 }
[17:28:17.006]                 NAMES <- toupper(added)
[17:28:17.006]                 for (kk in seq_along(NAMES)) {
[17:28:17.006]                   name <- added[[kk]]
[17:28:17.006]                   NAME <- NAMES[[kk]]
[17:28:17.006]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.006]                     next
[17:28:17.006]                   args[[name]] <- ""
[17:28:17.006]                 }
[17:28:17.006]                 NAMES <- toupper(removed)
[17:28:17.006]                 for (kk in seq_along(NAMES)) {
[17:28:17.006]                   name <- removed[[kk]]
[17:28:17.006]                   NAME <- NAMES[[kk]]
[17:28:17.006]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.006]                     next
[17:28:17.006]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.006]                 }
[17:28:17.006]                 if (length(args) > 0) 
[17:28:17.006]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.006]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.006]             }
[17:28:17.006]             else {
[17:28:17.006]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.006]             }
[17:28:17.006]             {
[17:28:17.006]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.006]                   0L) {
[17:28:17.006]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.006]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.006]                   base::options(opts)
[17:28:17.006]                 }
[17:28:17.006]                 {
[17:28:17.006]                   {
[17:28:17.006]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:17.006]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:17.006]                     -1344458670L), envir = base::globalenv(), 
[17:28:17.006]                       inherits = FALSE)
[17:28:17.006]                     NULL
[17:28:17.006]                   }
[17:28:17.006]                   options(future.plan = NULL)
[17:28:17.006]                   if (is.na(NA_character_)) 
[17:28:17.006]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.006]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.006]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.006]                     .init = FALSE)
[17:28:17.006]                 }
[17:28:17.006]             }
[17:28:17.006]         }
[17:28:17.006]     })
[17:28:17.006]     if (TRUE) {
[17:28:17.006]         base::sink(type = "output", split = FALSE)
[17:28:17.006]         if (TRUE) {
[17:28:17.006]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.006]         }
[17:28:17.006]         else {
[17:28:17.006]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.006]         }
[17:28:17.006]         base::close(...future.stdout)
[17:28:17.006]         ...future.stdout <- NULL
[17:28:17.006]     }
[17:28:17.006]     ...future.result$conditions <- ...future.conditions
[17:28:17.006]     ...future.result$finished <- base::Sys.time()
[17:28:17.006]     ...future.result
[17:28:17.006] }
[17:28:17.010] assign_globals() ...
[17:28:17.010] List of 1
[17:28:17.010]  $ x: int [1:4] 0 1 2 3
[17:28:17.010]  - attr(*, "where")=List of 1
[17:28:17.010]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.010]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.010]  - attr(*, "resolved")= logi FALSE
[17:28:17.010]  - attr(*, "total_size")= num 64
[17:28:17.010]  - attr(*, "already-done")= logi TRUE
[17:28:17.016] - copied 'x' to environment
[17:28:17.016] assign_globals() ... done
[17:28:17.016] plan(): Setting new future strategy stack:
[17:28:17.016] List of future strategies:
[17:28:17.016] 1. sequential:
[17:28:17.016]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.016]    - tweaked: FALSE
[17:28:17.016]    - call: NULL
[17:28:17.017] plan(): nbrOfWorkers() = 1
[17:28:17.019] plan(): Setting new future strategy stack:
[17:28:17.019] List of future strategies:
[17:28:17.019] 1. sequential:
[17:28:17.019]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.019]    - tweaked: FALSE
[17:28:17.019]    - call: plan("sequential")
[17:28:17.020] plan(): nbrOfWorkers() = 1
[17:28:17.020] SequentialFuture started (and completed)
[17:28:17.021] - Launch lazy future ... done
[17:28:17.021] run() for 'SequentialFuture' ... done
[17:28:17.021] getGlobalsAndPackages() ...
[17:28:17.023] Searching for globals...
[17:28:17.024] - globals found: [3] '{', 'sample', 'x'
[17:28:17.024] Searching for globals ... DONE
[17:28:17.024] Resolving globals: FALSE
[17:28:17.025] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.025] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.025] - globals: [1] 'x'
[17:28:17.026] 
[17:28:17.026] getGlobalsAndPackages() ... DONE
[17:28:17.026] run() for 'Future' ...
[17:28:17.026] - state: 'created'
[17:28:17.026] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.027] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.027] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.027]   - Field: 'label'
[17:28:17.027]   - Field: 'local'
[17:28:17.028]   - Field: 'owner'
[17:28:17.028]   - Field: 'envir'
[17:28:17.028]   - Field: 'packages'
[17:28:17.028]   - Field: 'gc'
[17:28:17.028]   - Field: 'conditions'
[17:28:17.028]   - Field: 'expr'
[17:28:17.029]   - Field: 'uuid'
[17:28:17.029]   - Field: 'seed'
[17:28:17.029]   - Field: 'version'
[17:28:17.029]   - Field: 'result'
[17:28:17.029]   - Field: 'asynchronous'
[17:28:17.029]   - Field: 'calls'
[17:28:17.030]   - Field: 'globals'
[17:28:17.030]   - Field: 'stdout'
[17:28:17.030]   - Field: 'earlySignal'
[17:28:17.030]   - Field: 'lazy'
[17:28:17.030]   - Field: 'state'
[17:28:17.030] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.031] - Launch lazy future ...
[17:28:17.031] Packages needed by the future expression (n = 0): <none>
[17:28:17.031] Packages needed by future strategies (n = 0): <none>
[17:28:17.032] {
[17:28:17.032]     {
[17:28:17.032]         {
[17:28:17.032]             ...future.startTime <- base::Sys.time()
[17:28:17.032]             {
[17:28:17.032]                 {
[17:28:17.032]                   {
[17:28:17.032]                     {
[17:28:17.032]                       base::local({
[17:28:17.032]                         has_future <- base::requireNamespace("future", 
[17:28:17.032]                           quietly = TRUE)
[17:28:17.032]                         if (has_future) {
[17:28:17.032]                           ns <- base::getNamespace("future")
[17:28:17.032]                           version <- ns[[".package"]][["version"]]
[17:28:17.032]                           if (is.null(version)) 
[17:28:17.032]                             version <- utils::packageVersion("future")
[17:28:17.032]                         }
[17:28:17.032]                         else {
[17:28:17.032]                           version <- NULL
[17:28:17.032]                         }
[17:28:17.032]                         if (!has_future || version < "1.8.0") {
[17:28:17.032]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.032]                             "", base::R.version$version.string), 
[17:28:17.032]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:17.032]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.032]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.032]                               "release", "version")], collapse = " "), 
[17:28:17.032]                             hostname = base::Sys.info()[["nodename"]])
[17:28:17.032]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.032]                             info)
[17:28:17.032]                           info <- base::paste(info, collapse = "; ")
[17:28:17.032]                           if (!has_future) {
[17:28:17.032]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.032]                               info)
[17:28:17.032]                           }
[17:28:17.032]                           else {
[17:28:17.032]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.032]                               info, version)
[17:28:17.032]                           }
[17:28:17.032]                           base::stop(msg)
[17:28:17.032]                         }
[17:28:17.032]                       })
[17:28:17.032]                     }
[17:28:17.032]                     ...future.strategy.old <- future::plan("list")
[17:28:17.032]                     options(future.plan = NULL)
[17:28:17.032]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.032]                     future::plan("default", .cleanup = FALSE, 
[17:28:17.032]                       .init = FALSE)
[17:28:17.032]                   }
[17:28:17.032]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:28:17.032]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:28:17.032]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:28:17.032]                 }
[17:28:17.032]                 ...future.workdir <- getwd()
[17:28:17.032]             }
[17:28:17.032]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.032]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.032]         }
[17:28:17.032]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.032]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.032]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.032]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.032]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.032]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.032]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.032]             base::names(...future.oldOptions))
[17:28:17.032]     }
[17:28:17.032]     if (FALSE) {
[17:28:17.032]     }
[17:28:17.032]     else {
[17:28:17.032]         if (TRUE) {
[17:28:17.032]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.032]                 open = "w")
[17:28:17.032]         }
[17:28:17.032]         else {
[17:28:17.032]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.032]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.032]         }
[17:28:17.032]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.032]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.032]             base::sink(type = "output", split = FALSE)
[17:28:17.032]             base::close(...future.stdout)
[17:28:17.032]         }, add = TRUE)
[17:28:17.032]     }
[17:28:17.032]     ...future.frame <- base::sys.nframe()
[17:28:17.032]     ...future.conditions <- base::list()
[17:28:17.032]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.032]     if (FALSE) {
[17:28:17.032]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.032]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.032]     }
[17:28:17.032]     ...future.result <- base::tryCatch({
[17:28:17.032]         base::withCallingHandlers({
[17:28:17.032]             ...future.value <- base::withVisible(base::local({
[17:28:17.032]                 sample(x, size = 1L)
[17:28:17.032]             }))
[17:28:17.032]             future::FutureResult(value = ...future.value$value, 
[17:28:17.032]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.032]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.032]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.032]                     ...future.globalenv.names))
[17:28:17.032]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.032]         }, condition = base::local({
[17:28:17.032]             c <- base::c
[17:28:17.032]             inherits <- base::inherits
[17:28:17.032]             invokeRestart <- base::invokeRestart
[17:28:17.032]             length <- base::length
[17:28:17.032]             list <- base::list
[17:28:17.032]             seq.int <- base::seq.int
[17:28:17.032]             signalCondition <- base::signalCondition
[17:28:17.032]             sys.calls <- base::sys.calls
[17:28:17.032]             `[[` <- base::`[[`
[17:28:17.032]             `+` <- base::`+`
[17:28:17.032]             `<<-` <- base::`<<-`
[17:28:17.032]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.032]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.032]                   3L)]
[17:28:17.032]             }
[17:28:17.032]             function(cond) {
[17:28:17.032]                 is_error <- inherits(cond, "error")
[17:28:17.032]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.032]                   NULL)
[17:28:17.032]                 if (is_error) {
[17:28:17.032]                   sessionInformation <- function() {
[17:28:17.032]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.032]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.032]                       search = base::search(), system = base::Sys.info())
[17:28:17.032]                   }
[17:28:17.032]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.032]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.032]                     cond$call), session = sessionInformation(), 
[17:28:17.032]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.032]                   signalCondition(cond)
[17:28:17.032]                 }
[17:28:17.032]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.032]                 "immediateCondition"))) {
[17:28:17.032]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.032]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.032]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.032]                   if (TRUE && !signal) {
[17:28:17.032]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.032]                     {
[17:28:17.032]                       inherits <- base::inherits
[17:28:17.032]                       invokeRestart <- base::invokeRestart
[17:28:17.032]                       is.null <- base::is.null
[17:28:17.032]                       muffled <- FALSE
[17:28:17.032]                       if (inherits(cond, "message")) {
[17:28:17.032]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.032]                         if (muffled) 
[17:28:17.032]                           invokeRestart("muffleMessage")
[17:28:17.032]                       }
[17:28:17.032]                       else if (inherits(cond, "warning")) {
[17:28:17.032]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.032]                         if (muffled) 
[17:28:17.032]                           invokeRestart("muffleWarning")
[17:28:17.032]                       }
[17:28:17.032]                       else if (inherits(cond, "condition")) {
[17:28:17.032]                         if (!is.null(pattern)) {
[17:28:17.032]                           computeRestarts <- base::computeRestarts
[17:28:17.032]                           grepl <- base::grepl
[17:28:17.032]                           restarts <- computeRestarts(cond)
[17:28:17.032]                           for (restart in restarts) {
[17:28:17.032]                             name <- restart$name
[17:28:17.032]                             if (is.null(name)) 
[17:28:17.032]                               next
[17:28:17.032]                             if (!grepl(pattern, name)) 
[17:28:17.032]                               next
[17:28:17.032]                             invokeRestart(restart)
[17:28:17.032]                             muffled <- TRUE
[17:28:17.032]                             break
[17:28:17.032]                           }
[17:28:17.032]                         }
[17:28:17.032]                       }
[17:28:17.032]                       invisible(muffled)
[17:28:17.032]                     }
[17:28:17.032]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.032]                   }
[17:28:17.032]                 }
[17:28:17.032]                 else {
[17:28:17.032]                   if (TRUE) {
[17:28:17.032]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.032]                     {
[17:28:17.032]                       inherits <- base::inherits
[17:28:17.032]                       invokeRestart <- base::invokeRestart
[17:28:17.032]                       is.null <- base::is.null
[17:28:17.032]                       muffled <- FALSE
[17:28:17.032]                       if (inherits(cond, "message")) {
[17:28:17.032]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.032]                         if (muffled) 
[17:28:17.032]                           invokeRestart("muffleMessage")
[17:28:17.032]                       }
[17:28:17.032]                       else if (inherits(cond, "warning")) {
[17:28:17.032]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.032]                         if (muffled) 
[17:28:17.032]                           invokeRestart("muffleWarning")
[17:28:17.032]                       }
[17:28:17.032]                       else if (inherits(cond, "condition")) {
[17:28:17.032]                         if (!is.null(pattern)) {
[17:28:17.032]                           computeRestarts <- base::computeRestarts
[17:28:17.032]                           grepl <- base::grepl
[17:28:17.032]                           restarts <- computeRestarts(cond)
[17:28:17.032]                           for (restart in restarts) {
[17:28:17.032]                             name <- restart$name
[17:28:17.032]                             if (is.null(name)) 
[17:28:17.032]                               next
[17:28:17.032]                             if (!grepl(pattern, name)) 
[17:28:17.032]                               next
[17:28:17.032]                             invokeRestart(restart)
[17:28:17.032]                             muffled <- TRUE
[17:28:17.032]                             break
[17:28:17.032]                           }
[17:28:17.032]                         }
[17:28:17.032]                       }
[17:28:17.032]                       invisible(muffled)
[17:28:17.032]                     }
[17:28:17.032]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.032]                   }
[17:28:17.032]                 }
[17:28:17.032]             }
[17:28:17.032]         }))
[17:28:17.032]     }, error = function(ex) {
[17:28:17.032]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.032]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.032]                 ...future.rng), started = ...future.startTime, 
[17:28:17.032]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.032]             version = "1.8"), class = "FutureResult")
[17:28:17.032]     }, finally = {
[17:28:17.032]         if (!identical(...future.workdir, getwd())) 
[17:28:17.032]             setwd(...future.workdir)
[17:28:17.032]         {
[17:28:17.032]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.032]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.032]             }
[17:28:17.032]             base::options(...future.oldOptions)
[17:28:17.032]             if (.Platform$OS.type == "windows") {
[17:28:17.032]                 old_names <- names(...future.oldEnvVars)
[17:28:17.032]                 envs <- base::Sys.getenv()
[17:28:17.032]                 names <- names(envs)
[17:28:17.032]                 common <- intersect(names, old_names)
[17:28:17.032]                 added <- setdiff(names, old_names)
[17:28:17.032]                 removed <- setdiff(old_names, names)
[17:28:17.032]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.032]                   envs[common]]
[17:28:17.032]                 NAMES <- toupper(changed)
[17:28:17.032]                 args <- list()
[17:28:17.032]                 for (kk in seq_along(NAMES)) {
[17:28:17.032]                   name <- changed[[kk]]
[17:28:17.032]                   NAME <- NAMES[[kk]]
[17:28:17.032]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.032]                     next
[17:28:17.032]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.032]                 }
[17:28:17.032]                 NAMES <- toupper(added)
[17:28:17.032]                 for (kk in seq_along(NAMES)) {
[17:28:17.032]                   name <- added[[kk]]
[17:28:17.032]                   NAME <- NAMES[[kk]]
[17:28:17.032]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.032]                     next
[17:28:17.032]                   args[[name]] <- ""
[17:28:17.032]                 }
[17:28:17.032]                 NAMES <- toupper(removed)
[17:28:17.032]                 for (kk in seq_along(NAMES)) {
[17:28:17.032]                   name <- removed[[kk]]
[17:28:17.032]                   NAME <- NAMES[[kk]]
[17:28:17.032]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.032]                     next
[17:28:17.032]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.032]                 }
[17:28:17.032]                 if (length(args) > 0) 
[17:28:17.032]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.032]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.032]             }
[17:28:17.032]             else {
[17:28:17.032]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.032]             }
[17:28:17.032]             {
[17:28:17.032]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.032]                   0L) {
[17:28:17.032]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.032]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.032]                   base::options(opts)
[17:28:17.032]                 }
[17:28:17.032]                 {
[17:28:17.032]                   {
[17:28:17.032]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:17.032]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:17.032]                     -1344458670L), envir = base::globalenv(), 
[17:28:17.032]                       inherits = FALSE)
[17:28:17.032]                     NULL
[17:28:17.032]                   }
[17:28:17.032]                   options(future.plan = NULL)
[17:28:17.032]                   if (is.na(NA_character_)) 
[17:28:17.032]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.032]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.032]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.032]                     .init = FALSE)
[17:28:17.032]                 }
[17:28:17.032]             }
[17:28:17.032]         }
[17:28:17.032]     })
[17:28:17.032]     if (TRUE) {
[17:28:17.032]         base::sink(type = "output", split = FALSE)
[17:28:17.032]         if (TRUE) {
[17:28:17.032]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.032]         }
[17:28:17.032]         else {
[17:28:17.032]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.032]         }
[17:28:17.032]         base::close(...future.stdout)
[17:28:17.032]         ...future.stdout <- NULL
[17:28:17.032]     }
[17:28:17.032]     ...future.result$conditions <- ...future.conditions
[17:28:17.032]     ...future.result$finished <- base::Sys.time()
[17:28:17.032]     ...future.result
[17:28:17.032] }
[17:28:17.035] assign_globals() ...
[17:28:17.036] List of 1
[17:28:17.036]  $ x: int [1:4] 0 1 2 3
[17:28:17.036]  - attr(*, "where")=List of 1
[17:28:17.036]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.036]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.036]  - attr(*, "resolved")= logi FALSE
[17:28:17.036]  - attr(*, "total_size")= num 64
[17:28:17.036]  - attr(*, "already-done")= logi TRUE
[17:28:17.039] - copied 'x' to environment
[17:28:17.039] assign_globals() ... done
[17:28:17.039] plan(): Setting new future strategy stack:
[17:28:17.039] List of future strategies:
[17:28:17.039] 1. sequential:
[17:28:17.039]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.039]    - tweaked: FALSE
[17:28:17.039]    - call: NULL
[17:28:17.040] plan(): nbrOfWorkers() = 1
[17:28:17.041] plan(): Setting new future strategy stack:
[17:28:17.041] List of future strategies:
[17:28:17.041] 1. sequential:
[17:28:17.041]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.041]    - tweaked: FALSE
[17:28:17.041]    - call: plan("sequential")
[17:28:17.042] plan(): nbrOfWorkers() = 1
[17:28:17.042] SequentialFuture started (and completed)
[17:28:17.042] - Launch lazy future ... done
[17:28:17.042] run() for 'SequentialFuture' ... done
[17:28:17.043] getGlobalsAndPackages() ...
[17:28:17.043] Searching for globals...
[17:28:17.044] - globals found: [3] '{', 'sample', 'x'
[17:28:17.044] Searching for globals ... DONE
[17:28:17.044] Resolving globals: FALSE
[17:28:17.045] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.045] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.045] - globals: [1] 'x'
[17:28:17.045] 
[17:28:17.046] getGlobalsAndPackages() ... DONE
[17:28:17.046] run() for 'Future' ...
[17:28:17.046] - state: 'created'
[17:28:17.046] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.047] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.047] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.047]   - Field: 'label'
[17:28:17.047]   - Field: 'local'
[17:28:17.047]   - Field: 'owner'
[17:28:17.048]   - Field: 'envir'
[17:28:17.048]   - Field: 'packages'
[17:28:17.048]   - Field: 'gc'
[17:28:17.048]   - Field: 'conditions'
[17:28:17.048]   - Field: 'expr'
[17:28:17.048]   - Field: 'uuid'
[17:28:17.049]   - Field: 'seed'
[17:28:17.049]   - Field: 'version'
[17:28:17.049]   - Field: 'result'
[17:28:17.049]   - Field: 'asynchronous'
[17:28:17.049]   - Field: 'calls'
[17:28:17.049]   - Field: 'globals'
[17:28:17.050]   - Field: 'stdout'
[17:28:17.050]   - Field: 'earlySignal'
[17:28:17.050]   - Field: 'lazy'
[17:28:17.050]   - Field: 'state'
[17:28:17.050] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.050] - Launch lazy future ...
[17:28:17.051] Packages needed by the future expression (n = 0): <none>
[17:28:17.051] Packages needed by future strategies (n = 0): <none>
[17:28:17.051] {
[17:28:17.051]     {
[17:28:17.051]         {
[17:28:17.051]             ...future.startTime <- base::Sys.time()
[17:28:17.051]             {
[17:28:17.051]                 {
[17:28:17.051]                   {
[17:28:17.051]                     {
[17:28:17.051]                       base::local({
[17:28:17.051]                         has_future <- base::requireNamespace("future", 
[17:28:17.051]                           quietly = TRUE)
[17:28:17.051]                         if (has_future) {
[17:28:17.051]                           ns <- base::getNamespace("future")
[17:28:17.051]                           version <- ns[[".package"]][["version"]]
[17:28:17.051]                           if (is.null(version)) 
[17:28:17.051]                             version <- utils::packageVersion("future")
[17:28:17.051]                         }
[17:28:17.051]                         else {
[17:28:17.051]                           version <- NULL
[17:28:17.051]                         }
[17:28:17.051]                         if (!has_future || version < "1.8.0") {
[17:28:17.051]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.051]                             "", base::R.version$version.string), 
[17:28:17.051]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:17.051]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.051]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.051]                               "release", "version")], collapse = " "), 
[17:28:17.051]                             hostname = base::Sys.info()[["nodename"]])
[17:28:17.051]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.051]                             info)
[17:28:17.051]                           info <- base::paste(info, collapse = "; ")
[17:28:17.051]                           if (!has_future) {
[17:28:17.051]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.051]                               info)
[17:28:17.051]                           }
[17:28:17.051]                           else {
[17:28:17.051]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.051]                               info, version)
[17:28:17.051]                           }
[17:28:17.051]                           base::stop(msg)
[17:28:17.051]                         }
[17:28:17.051]                       })
[17:28:17.051]                     }
[17:28:17.051]                     ...future.strategy.old <- future::plan("list")
[17:28:17.051]                     options(future.plan = NULL)
[17:28:17.051]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.051]                     future::plan("default", .cleanup = FALSE, 
[17:28:17.051]                       .init = FALSE)
[17:28:17.051]                   }
[17:28:17.051]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:28:17.051]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:28:17.051]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:28:17.051]                 }
[17:28:17.051]                 ...future.workdir <- getwd()
[17:28:17.051]             }
[17:28:17.051]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.051]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.051]         }
[17:28:17.051]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.051]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.051]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.051]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.051]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.051]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.051]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.051]             base::names(...future.oldOptions))
[17:28:17.051]     }
[17:28:17.051]     if (FALSE) {
[17:28:17.051]     }
[17:28:17.051]     else {
[17:28:17.051]         if (TRUE) {
[17:28:17.051]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.051]                 open = "w")
[17:28:17.051]         }
[17:28:17.051]         else {
[17:28:17.051]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.051]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.051]         }
[17:28:17.051]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.051]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.051]             base::sink(type = "output", split = FALSE)
[17:28:17.051]             base::close(...future.stdout)
[17:28:17.051]         }, add = TRUE)
[17:28:17.051]     }
[17:28:17.051]     ...future.frame <- base::sys.nframe()
[17:28:17.051]     ...future.conditions <- base::list()
[17:28:17.051]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.051]     if (FALSE) {
[17:28:17.051]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.051]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.051]     }
[17:28:17.051]     ...future.result <- base::tryCatch({
[17:28:17.051]         base::withCallingHandlers({
[17:28:17.051]             ...future.value <- base::withVisible(base::local({
[17:28:17.051]                 sample(x, size = 1L)
[17:28:17.051]             }))
[17:28:17.051]             future::FutureResult(value = ...future.value$value, 
[17:28:17.051]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.051]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.051]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.051]                     ...future.globalenv.names))
[17:28:17.051]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.051]         }, condition = base::local({
[17:28:17.051]             c <- base::c
[17:28:17.051]             inherits <- base::inherits
[17:28:17.051]             invokeRestart <- base::invokeRestart
[17:28:17.051]             length <- base::length
[17:28:17.051]             list <- base::list
[17:28:17.051]             seq.int <- base::seq.int
[17:28:17.051]             signalCondition <- base::signalCondition
[17:28:17.051]             sys.calls <- base::sys.calls
[17:28:17.051]             `[[` <- base::`[[`
[17:28:17.051]             `+` <- base::`+`
[17:28:17.051]             `<<-` <- base::`<<-`
[17:28:17.051]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.051]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.051]                   3L)]
[17:28:17.051]             }
[17:28:17.051]             function(cond) {
[17:28:17.051]                 is_error <- inherits(cond, "error")
[17:28:17.051]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.051]                   NULL)
[17:28:17.051]                 if (is_error) {
[17:28:17.051]                   sessionInformation <- function() {
[17:28:17.051]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.051]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.051]                       search = base::search(), system = base::Sys.info())
[17:28:17.051]                   }
[17:28:17.051]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.051]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.051]                     cond$call), session = sessionInformation(), 
[17:28:17.051]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.051]                   signalCondition(cond)
[17:28:17.051]                 }
[17:28:17.051]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.051]                 "immediateCondition"))) {
[17:28:17.051]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.051]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.051]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.051]                   if (TRUE && !signal) {
[17:28:17.051]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.051]                     {
[17:28:17.051]                       inherits <- base::inherits
[17:28:17.051]                       invokeRestart <- base::invokeRestart
[17:28:17.051]                       is.null <- base::is.null
[17:28:17.051]                       muffled <- FALSE
[17:28:17.051]                       if (inherits(cond, "message")) {
[17:28:17.051]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.051]                         if (muffled) 
[17:28:17.051]                           invokeRestart("muffleMessage")
[17:28:17.051]                       }
[17:28:17.051]                       else if (inherits(cond, "warning")) {
[17:28:17.051]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.051]                         if (muffled) 
[17:28:17.051]                           invokeRestart("muffleWarning")
[17:28:17.051]                       }
[17:28:17.051]                       else if (inherits(cond, "condition")) {
[17:28:17.051]                         if (!is.null(pattern)) {
[17:28:17.051]                           computeRestarts <- base::computeRestarts
[17:28:17.051]                           grepl <- base::grepl
[17:28:17.051]                           restarts <- computeRestarts(cond)
[17:28:17.051]                           for (restart in restarts) {
[17:28:17.051]                             name <- restart$name
[17:28:17.051]                             if (is.null(name)) 
[17:28:17.051]                               next
[17:28:17.051]                             if (!grepl(pattern, name)) 
[17:28:17.051]                               next
[17:28:17.051]                             invokeRestart(restart)
[17:28:17.051]                             muffled <- TRUE
[17:28:17.051]                             break
[17:28:17.051]                           }
[17:28:17.051]                         }
[17:28:17.051]                       }
[17:28:17.051]                       invisible(muffled)
[17:28:17.051]                     }
[17:28:17.051]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.051]                   }
[17:28:17.051]                 }
[17:28:17.051]                 else {
[17:28:17.051]                   if (TRUE) {
[17:28:17.051]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.051]                     {
[17:28:17.051]                       inherits <- base::inherits
[17:28:17.051]                       invokeRestart <- base::invokeRestart
[17:28:17.051]                       is.null <- base::is.null
[17:28:17.051]                       muffled <- FALSE
[17:28:17.051]                       if (inherits(cond, "message")) {
[17:28:17.051]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.051]                         if (muffled) 
[17:28:17.051]                           invokeRestart("muffleMessage")
[17:28:17.051]                       }
[17:28:17.051]                       else if (inherits(cond, "warning")) {
[17:28:17.051]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.051]                         if (muffled) 
[17:28:17.051]                           invokeRestart("muffleWarning")
[17:28:17.051]                       }
[17:28:17.051]                       else if (inherits(cond, "condition")) {
[17:28:17.051]                         if (!is.null(pattern)) {
[17:28:17.051]                           computeRestarts <- base::computeRestarts
[17:28:17.051]                           grepl <- base::grepl
[17:28:17.051]                           restarts <- computeRestarts(cond)
[17:28:17.051]                           for (restart in restarts) {
[17:28:17.051]                             name <- restart$name
[17:28:17.051]                             if (is.null(name)) 
[17:28:17.051]                               next
[17:28:17.051]                             if (!grepl(pattern, name)) 
[17:28:17.051]                               next
[17:28:17.051]                             invokeRestart(restart)
[17:28:17.051]                             muffled <- TRUE
[17:28:17.051]                             break
[17:28:17.051]                           }
[17:28:17.051]                         }
[17:28:17.051]                       }
[17:28:17.051]                       invisible(muffled)
[17:28:17.051]                     }
[17:28:17.051]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.051]                   }
[17:28:17.051]                 }
[17:28:17.051]             }
[17:28:17.051]         }))
[17:28:17.051]     }, error = function(ex) {
[17:28:17.051]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.051]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.051]                 ...future.rng), started = ...future.startTime, 
[17:28:17.051]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.051]             version = "1.8"), class = "FutureResult")
[17:28:17.051]     }, finally = {
[17:28:17.051]         if (!identical(...future.workdir, getwd())) 
[17:28:17.051]             setwd(...future.workdir)
[17:28:17.051]         {
[17:28:17.051]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.051]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.051]             }
[17:28:17.051]             base::options(...future.oldOptions)
[17:28:17.051]             if (.Platform$OS.type == "windows") {
[17:28:17.051]                 old_names <- names(...future.oldEnvVars)
[17:28:17.051]                 envs <- base::Sys.getenv()
[17:28:17.051]                 names <- names(envs)
[17:28:17.051]                 common <- intersect(names, old_names)
[17:28:17.051]                 added <- setdiff(names, old_names)
[17:28:17.051]                 removed <- setdiff(old_names, names)
[17:28:17.051]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.051]                   envs[common]]
[17:28:17.051]                 NAMES <- toupper(changed)
[17:28:17.051]                 args <- list()
[17:28:17.051]                 for (kk in seq_along(NAMES)) {
[17:28:17.051]                   name <- changed[[kk]]
[17:28:17.051]                   NAME <- NAMES[[kk]]
[17:28:17.051]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.051]                     next
[17:28:17.051]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.051]                 }
[17:28:17.051]                 NAMES <- toupper(added)
[17:28:17.051]                 for (kk in seq_along(NAMES)) {
[17:28:17.051]                   name <- added[[kk]]
[17:28:17.051]                   NAME <- NAMES[[kk]]
[17:28:17.051]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.051]                     next
[17:28:17.051]                   args[[name]] <- ""
[17:28:17.051]                 }
[17:28:17.051]                 NAMES <- toupper(removed)
[17:28:17.051]                 for (kk in seq_along(NAMES)) {
[17:28:17.051]                   name <- removed[[kk]]
[17:28:17.051]                   NAME <- NAMES[[kk]]
[17:28:17.051]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.051]                     next
[17:28:17.051]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.051]                 }
[17:28:17.051]                 if (length(args) > 0) 
[17:28:17.051]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.051]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.051]             }
[17:28:17.051]             else {
[17:28:17.051]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.051]             }
[17:28:17.051]             {
[17:28:17.051]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.051]                   0L) {
[17:28:17.051]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.051]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.051]                   base::options(opts)
[17:28:17.051]                 }
[17:28:17.051]                 {
[17:28:17.051]                   {
[17:28:17.051]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:17.051]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:17.051]                     -1344458670L), envir = base::globalenv(), 
[17:28:17.051]                       inherits = FALSE)
[17:28:17.051]                     NULL
[17:28:17.051]                   }
[17:28:17.051]                   options(future.plan = NULL)
[17:28:17.051]                   if (is.na(NA_character_)) 
[17:28:17.051]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.051]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.051]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.051]                     .init = FALSE)
[17:28:17.051]                 }
[17:28:17.051]             }
[17:28:17.051]         }
[17:28:17.051]     })
[17:28:17.051]     if (TRUE) {
[17:28:17.051]         base::sink(type = "output", split = FALSE)
[17:28:17.051]         if (TRUE) {
[17:28:17.051]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.051]         }
[17:28:17.051]         else {
[17:28:17.051]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.051]         }
[17:28:17.051]         base::close(...future.stdout)
[17:28:17.051]         ...future.stdout <- NULL
[17:28:17.051]     }
[17:28:17.051]     ...future.result$conditions <- ...future.conditions
[17:28:17.051]     ...future.result$finished <- base::Sys.time()
[17:28:17.051]     ...future.result
[17:28:17.051] }
[17:28:17.055] assign_globals() ...
[17:28:17.055] List of 1
[17:28:17.055]  $ x: int [1:4] 0 1 2 3
[17:28:17.055]  - attr(*, "where")=List of 1
[17:28:17.055]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.055]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.055]  - attr(*, "resolved")= logi FALSE
[17:28:17.055]  - attr(*, "total_size")= num 64
[17:28:17.055]  - attr(*, "already-done")= logi TRUE
[17:28:17.058] - copied 'x' to environment
[17:28:17.059] assign_globals() ... done
[17:28:17.059] plan(): Setting new future strategy stack:
[17:28:17.060] List of future strategies:
[17:28:17.060] 1. sequential:
[17:28:17.060]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.060]    - tweaked: FALSE
[17:28:17.060]    - call: NULL
[17:28:17.061] plan(): nbrOfWorkers() = 1
[17:28:17.062] plan(): Setting new future strategy stack:
[17:28:17.062] List of future strategies:
[17:28:17.062] 1. sequential:
[17:28:17.062]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.062]    - tweaked: FALSE
[17:28:17.062]    - call: plan("sequential")
[17:28:17.062] plan(): nbrOfWorkers() = 1
[17:28:17.063] SequentialFuture started (and completed)
[17:28:17.063] - Launch lazy future ... done
[17:28:17.063] run() for 'SequentialFuture' ... done
[17:28:17.063] getGlobalsAndPackages() ...
[17:28:17.063] Searching for globals...
[17:28:17.065] - globals found: [3] '{', 'sample', 'x'
[17:28:17.065] Searching for globals ... DONE
[17:28:17.065] Resolving globals: FALSE
[17:28:17.065] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.066] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.066] - globals: [1] 'x'
[17:28:17.066] 
[17:28:17.066] getGlobalsAndPackages() ... DONE
[17:28:17.067] run() for 'Future' ...
[17:28:17.067] - state: 'created'
[17:28:17.067] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.067] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.068] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.068]   - Field: 'label'
[17:28:17.068]   - Field: 'local'
[17:28:17.068]   - Field: 'owner'
[17:28:17.068]   - Field: 'envir'
[17:28:17.068]   - Field: 'packages'
[17:28:17.069]   - Field: 'gc'
[17:28:17.069]   - Field: 'conditions'
[17:28:17.069]   - Field: 'expr'
[17:28:17.069]   - Field: 'uuid'
[17:28:17.069]   - Field: 'seed'
[17:28:17.070]   - Field: 'version'
[17:28:17.070]   - Field: 'result'
[17:28:17.070]   - Field: 'asynchronous'
[17:28:17.070]   - Field: 'calls'
[17:28:17.070]   - Field: 'globals'
[17:28:17.070]   - Field: 'stdout'
[17:28:17.071]   - Field: 'earlySignal'
[17:28:17.071]   - Field: 'lazy'
[17:28:17.071]   - Field: 'state'
[17:28:17.071] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.071] - Launch lazy future ...
[17:28:17.071] Packages needed by the future expression (n = 0): <none>
[17:28:17.072] Packages needed by future strategies (n = 0): <none>
[17:28:17.072] {
[17:28:17.072]     {
[17:28:17.072]         {
[17:28:17.072]             ...future.startTime <- base::Sys.time()
[17:28:17.072]             {
[17:28:17.072]                 {
[17:28:17.072]                   {
[17:28:17.072]                     {
[17:28:17.072]                       base::local({
[17:28:17.072]                         has_future <- base::requireNamespace("future", 
[17:28:17.072]                           quietly = TRUE)
[17:28:17.072]                         if (has_future) {
[17:28:17.072]                           ns <- base::getNamespace("future")
[17:28:17.072]                           version <- ns[[".package"]][["version"]]
[17:28:17.072]                           if (is.null(version)) 
[17:28:17.072]                             version <- utils::packageVersion("future")
[17:28:17.072]                         }
[17:28:17.072]                         else {
[17:28:17.072]                           version <- NULL
[17:28:17.072]                         }
[17:28:17.072]                         if (!has_future || version < "1.8.0") {
[17:28:17.072]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.072]                             "", base::R.version$version.string), 
[17:28:17.072]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:17.072]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.072]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.072]                               "release", "version")], collapse = " "), 
[17:28:17.072]                             hostname = base::Sys.info()[["nodename"]])
[17:28:17.072]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.072]                             info)
[17:28:17.072]                           info <- base::paste(info, collapse = "; ")
[17:28:17.072]                           if (!has_future) {
[17:28:17.072]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.072]                               info)
[17:28:17.072]                           }
[17:28:17.072]                           else {
[17:28:17.072]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.072]                               info, version)
[17:28:17.072]                           }
[17:28:17.072]                           base::stop(msg)
[17:28:17.072]                         }
[17:28:17.072]                       })
[17:28:17.072]                     }
[17:28:17.072]                     ...future.strategy.old <- future::plan("list")
[17:28:17.072]                     options(future.plan = NULL)
[17:28:17.072]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.072]                     future::plan("default", .cleanup = FALSE, 
[17:28:17.072]                       .init = FALSE)
[17:28:17.072]                   }
[17:28:17.072]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:28:17.072]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:28:17.072]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:28:17.072]                 }
[17:28:17.072]                 ...future.workdir <- getwd()
[17:28:17.072]             }
[17:28:17.072]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.072]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.072]         }
[17:28:17.072]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.072]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.072]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.072]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.072]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.072]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.072]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.072]             base::names(...future.oldOptions))
[17:28:17.072]     }
[17:28:17.072]     if (FALSE) {
[17:28:17.072]     }
[17:28:17.072]     else {
[17:28:17.072]         if (TRUE) {
[17:28:17.072]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.072]                 open = "w")
[17:28:17.072]         }
[17:28:17.072]         else {
[17:28:17.072]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.072]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.072]         }
[17:28:17.072]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.072]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.072]             base::sink(type = "output", split = FALSE)
[17:28:17.072]             base::close(...future.stdout)
[17:28:17.072]         }, add = TRUE)
[17:28:17.072]     }
[17:28:17.072]     ...future.frame <- base::sys.nframe()
[17:28:17.072]     ...future.conditions <- base::list()
[17:28:17.072]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.072]     if (FALSE) {
[17:28:17.072]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.072]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.072]     }
[17:28:17.072]     ...future.result <- base::tryCatch({
[17:28:17.072]         base::withCallingHandlers({
[17:28:17.072]             ...future.value <- base::withVisible(base::local({
[17:28:17.072]                 sample(x, size = 1L)
[17:28:17.072]             }))
[17:28:17.072]             future::FutureResult(value = ...future.value$value, 
[17:28:17.072]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.072]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.072]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.072]                     ...future.globalenv.names))
[17:28:17.072]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.072]         }, condition = base::local({
[17:28:17.072]             c <- base::c
[17:28:17.072]             inherits <- base::inherits
[17:28:17.072]             invokeRestart <- base::invokeRestart
[17:28:17.072]             length <- base::length
[17:28:17.072]             list <- base::list
[17:28:17.072]             seq.int <- base::seq.int
[17:28:17.072]             signalCondition <- base::signalCondition
[17:28:17.072]             sys.calls <- base::sys.calls
[17:28:17.072]             `[[` <- base::`[[`
[17:28:17.072]             `+` <- base::`+`
[17:28:17.072]             `<<-` <- base::`<<-`
[17:28:17.072]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.072]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.072]                   3L)]
[17:28:17.072]             }
[17:28:17.072]             function(cond) {
[17:28:17.072]                 is_error <- inherits(cond, "error")
[17:28:17.072]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.072]                   NULL)
[17:28:17.072]                 if (is_error) {
[17:28:17.072]                   sessionInformation <- function() {
[17:28:17.072]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.072]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.072]                       search = base::search(), system = base::Sys.info())
[17:28:17.072]                   }
[17:28:17.072]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.072]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.072]                     cond$call), session = sessionInformation(), 
[17:28:17.072]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.072]                   signalCondition(cond)
[17:28:17.072]                 }
[17:28:17.072]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.072]                 "immediateCondition"))) {
[17:28:17.072]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.072]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.072]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.072]                   if (TRUE && !signal) {
[17:28:17.072]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.072]                     {
[17:28:17.072]                       inherits <- base::inherits
[17:28:17.072]                       invokeRestart <- base::invokeRestart
[17:28:17.072]                       is.null <- base::is.null
[17:28:17.072]                       muffled <- FALSE
[17:28:17.072]                       if (inherits(cond, "message")) {
[17:28:17.072]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.072]                         if (muffled) 
[17:28:17.072]                           invokeRestart("muffleMessage")
[17:28:17.072]                       }
[17:28:17.072]                       else if (inherits(cond, "warning")) {
[17:28:17.072]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.072]                         if (muffled) 
[17:28:17.072]                           invokeRestart("muffleWarning")
[17:28:17.072]                       }
[17:28:17.072]                       else if (inherits(cond, "condition")) {
[17:28:17.072]                         if (!is.null(pattern)) {
[17:28:17.072]                           computeRestarts <- base::computeRestarts
[17:28:17.072]                           grepl <- base::grepl
[17:28:17.072]                           restarts <- computeRestarts(cond)
[17:28:17.072]                           for (restart in restarts) {
[17:28:17.072]                             name <- restart$name
[17:28:17.072]                             if (is.null(name)) 
[17:28:17.072]                               next
[17:28:17.072]                             if (!grepl(pattern, name)) 
[17:28:17.072]                               next
[17:28:17.072]                             invokeRestart(restart)
[17:28:17.072]                             muffled <- TRUE
[17:28:17.072]                             break
[17:28:17.072]                           }
[17:28:17.072]                         }
[17:28:17.072]                       }
[17:28:17.072]                       invisible(muffled)
[17:28:17.072]                     }
[17:28:17.072]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.072]                   }
[17:28:17.072]                 }
[17:28:17.072]                 else {
[17:28:17.072]                   if (TRUE) {
[17:28:17.072]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.072]                     {
[17:28:17.072]                       inherits <- base::inherits
[17:28:17.072]                       invokeRestart <- base::invokeRestart
[17:28:17.072]                       is.null <- base::is.null
[17:28:17.072]                       muffled <- FALSE
[17:28:17.072]                       if (inherits(cond, "message")) {
[17:28:17.072]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.072]                         if (muffled) 
[17:28:17.072]                           invokeRestart("muffleMessage")
[17:28:17.072]                       }
[17:28:17.072]                       else if (inherits(cond, "warning")) {
[17:28:17.072]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.072]                         if (muffled) 
[17:28:17.072]                           invokeRestart("muffleWarning")
[17:28:17.072]                       }
[17:28:17.072]                       else if (inherits(cond, "condition")) {
[17:28:17.072]                         if (!is.null(pattern)) {
[17:28:17.072]                           computeRestarts <- base::computeRestarts
[17:28:17.072]                           grepl <- base::grepl
[17:28:17.072]                           restarts <- computeRestarts(cond)
[17:28:17.072]                           for (restart in restarts) {
[17:28:17.072]                             name <- restart$name
[17:28:17.072]                             if (is.null(name)) 
[17:28:17.072]                               next
[17:28:17.072]                             if (!grepl(pattern, name)) 
[17:28:17.072]                               next
[17:28:17.072]                             invokeRestart(restart)
[17:28:17.072]                             muffled <- TRUE
[17:28:17.072]                             break
[17:28:17.072]                           }
[17:28:17.072]                         }
[17:28:17.072]                       }
[17:28:17.072]                       invisible(muffled)
[17:28:17.072]                     }
[17:28:17.072]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.072]                   }
[17:28:17.072]                 }
[17:28:17.072]             }
[17:28:17.072]         }))
[17:28:17.072]     }, error = function(ex) {
[17:28:17.072]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.072]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.072]                 ...future.rng), started = ...future.startTime, 
[17:28:17.072]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.072]             version = "1.8"), class = "FutureResult")
[17:28:17.072]     }, finally = {
[17:28:17.072]         if (!identical(...future.workdir, getwd())) 
[17:28:17.072]             setwd(...future.workdir)
[17:28:17.072]         {
[17:28:17.072]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.072]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.072]             }
[17:28:17.072]             base::options(...future.oldOptions)
[17:28:17.072]             if (.Platform$OS.type == "windows") {
[17:28:17.072]                 old_names <- names(...future.oldEnvVars)
[17:28:17.072]                 envs <- base::Sys.getenv()
[17:28:17.072]                 names <- names(envs)
[17:28:17.072]                 common <- intersect(names, old_names)
[17:28:17.072]                 added <- setdiff(names, old_names)
[17:28:17.072]                 removed <- setdiff(old_names, names)
[17:28:17.072]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.072]                   envs[common]]
[17:28:17.072]                 NAMES <- toupper(changed)
[17:28:17.072]                 args <- list()
[17:28:17.072]                 for (kk in seq_along(NAMES)) {
[17:28:17.072]                   name <- changed[[kk]]
[17:28:17.072]                   NAME <- NAMES[[kk]]
[17:28:17.072]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.072]                     next
[17:28:17.072]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.072]                 }
[17:28:17.072]                 NAMES <- toupper(added)
[17:28:17.072]                 for (kk in seq_along(NAMES)) {
[17:28:17.072]                   name <- added[[kk]]
[17:28:17.072]                   NAME <- NAMES[[kk]]
[17:28:17.072]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.072]                     next
[17:28:17.072]                   args[[name]] <- ""
[17:28:17.072]                 }
[17:28:17.072]                 NAMES <- toupper(removed)
[17:28:17.072]                 for (kk in seq_along(NAMES)) {
[17:28:17.072]                   name <- removed[[kk]]
[17:28:17.072]                   NAME <- NAMES[[kk]]
[17:28:17.072]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.072]                     next
[17:28:17.072]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.072]                 }
[17:28:17.072]                 if (length(args) > 0) 
[17:28:17.072]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.072]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.072]             }
[17:28:17.072]             else {
[17:28:17.072]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.072]             }
[17:28:17.072]             {
[17:28:17.072]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.072]                   0L) {
[17:28:17.072]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.072]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.072]                   base::options(opts)
[17:28:17.072]                 }
[17:28:17.072]                 {
[17:28:17.072]                   {
[17:28:17.072]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:17.072]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:17.072]                     -1344458670L), envir = base::globalenv(), 
[17:28:17.072]                       inherits = FALSE)
[17:28:17.072]                     NULL
[17:28:17.072]                   }
[17:28:17.072]                   options(future.plan = NULL)
[17:28:17.072]                   if (is.na(NA_character_)) 
[17:28:17.072]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.072]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.072]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.072]                     .init = FALSE)
[17:28:17.072]                 }
[17:28:17.072]             }
[17:28:17.072]         }
[17:28:17.072]     })
[17:28:17.072]     if (TRUE) {
[17:28:17.072]         base::sink(type = "output", split = FALSE)
[17:28:17.072]         if (TRUE) {
[17:28:17.072]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.072]         }
[17:28:17.072]         else {
[17:28:17.072]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.072]         }
[17:28:17.072]         base::close(...future.stdout)
[17:28:17.072]         ...future.stdout <- NULL
[17:28:17.072]     }
[17:28:17.072]     ...future.result$conditions <- ...future.conditions
[17:28:17.072]     ...future.result$finished <- base::Sys.time()
[17:28:17.072]     ...future.result
[17:28:17.072] }
[17:28:17.076] assign_globals() ...
[17:28:17.076] List of 1
[17:28:17.076]  $ x: int [1:4] 0 1 2 3
[17:28:17.076]  - attr(*, "where")=List of 1
[17:28:17.076]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.076]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.076]  - attr(*, "resolved")= logi FALSE
[17:28:17.076]  - attr(*, "total_size")= num 64
[17:28:17.076]  - attr(*, "already-done")= logi TRUE
[17:28:17.079] - copied 'x' to environment
[17:28:17.079] assign_globals() ... done
[17:28:17.080] plan(): Setting new future strategy stack:
[17:28:17.080] List of future strategies:
[17:28:17.080] 1. sequential:
[17:28:17.080]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.080]    - tweaked: FALSE
[17:28:17.080]    - call: NULL
[17:28:17.080] plan(): nbrOfWorkers() = 1
[17:28:17.081] plan(): Setting new future strategy stack:
[17:28:17.082] List of future strategies:
[17:28:17.082] 1. sequential:
[17:28:17.082]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.082]    - tweaked: FALSE
[17:28:17.082]    - call: plan("sequential")
[17:28:17.082] plan(): nbrOfWorkers() = 1
[17:28:17.082] SequentialFuture started (and completed)
[17:28:17.083] - Launch lazy future ... done
[17:28:17.083] run() for 'SequentialFuture' ... done
[17:28:17.083] resolve() on list ...
[17:28:17.083]  recursive: 0
[17:28:17.084]  length: 4
[17:28:17.084] 
[17:28:17.084] resolved() for 'SequentialFuture' ...
[17:28:17.084] - state: 'finished'
[17:28:17.085] - run: TRUE
[17:28:17.085] - result: 'FutureResult'
[17:28:17.085] resolved() for 'SequentialFuture' ... done
[17:28:17.085] Future #1
[17:28:17.086] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:28:17.086] - nx: 4
[17:28:17.086] - relay: TRUE
[17:28:17.086] - stdout: TRUE
[17:28:17.086] - signal: TRUE
[17:28:17.086] - resignal: FALSE
[17:28:17.086] - force: TRUE
[17:28:17.087] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.087] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.087]  - until=1
[17:28:17.087]  - relaying element #1
[17:28:17.087] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.088] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.088] signalConditionsASAP(SequentialFuture, pos=1) ... done
[17:28:17.088]  length: 3 (resolved future 1)
[17:28:17.088] resolved() for 'SequentialFuture' ...
[17:28:17.088] - state: 'finished'
[17:28:17.089] - run: TRUE
[17:28:17.089] - result: 'FutureResult'
[17:28:17.089] resolved() for 'SequentialFuture' ... done
[17:28:17.089] Future #2
[17:28:17.089] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:28:17.089] - nx: 4
[17:28:17.090] - relay: TRUE
[17:28:17.090] - stdout: TRUE
[17:28:17.090] - signal: TRUE
[17:28:17.090] - resignal: FALSE
[17:28:17.090] - force: TRUE
[17:28:17.090] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.091] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.091]  - until=2
[17:28:17.091]  - relaying element #2
[17:28:17.091] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.091] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.091] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:28:17.092]  length: 2 (resolved future 2)
[17:28:17.092] resolved() for 'SequentialFuture' ...
[17:28:17.092] - state: 'finished'
[17:28:17.092] - run: TRUE
[17:28:17.092] - result: 'FutureResult'
[17:28:17.093] resolved() for 'SequentialFuture' ... done
[17:28:17.093] Future #3
[17:28:17.093] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:28:17.093] - nx: 4
[17:28:17.093] - relay: TRUE
[17:28:17.093] - stdout: TRUE
[17:28:17.094] - signal: TRUE
[17:28:17.094] - resignal: FALSE
[17:28:17.094] - force: TRUE
[17:28:17.094] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.094] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.094]  - until=3
[17:28:17.095]  - relaying element #3
[17:28:17.096] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.096] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.096] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:28:17.096]  length: 1 (resolved future 3)
[17:28:17.096] resolved() for 'SequentialFuture' ...
[17:28:17.097] - state: 'finished'
[17:28:17.097] - run: TRUE
[17:28:17.097] - result: 'FutureResult'
[17:28:17.097] resolved() for 'SequentialFuture' ... done
[17:28:17.097] Future #4
[17:28:17.097] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:28:17.098] - nx: 4
[17:28:17.098] - relay: TRUE
[17:28:17.098] - stdout: TRUE
[17:28:17.098] - signal: TRUE
[17:28:17.098] - resignal: FALSE
[17:28:17.098] - force: TRUE
[17:28:17.099] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.099] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.099]  - until=4
[17:28:17.099]  - relaying element #4
[17:28:17.099] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.099] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.100] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:28:17.100]  length: 0 (resolved future 4)
[17:28:17.100] Relaying remaining futures
[17:28:17.100] signalConditionsASAP(NULL, pos=0) ...
[17:28:17.100] - nx: 4
[17:28:17.100] - relay: TRUE
[17:28:17.100] - stdout: TRUE
[17:28:17.101] - signal: TRUE
[17:28:17.101] - resignal: FALSE
[17:28:17.101] - force: TRUE
[17:28:17.101] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.101] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:28:17.101] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.102] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.102] signalConditionsASAP(NULL, pos=0) ... done
[17:28:17.102] 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:28:17.136] plan(): Setting new future strategy stack:
[17:28:17.136] List of future strategies:
[17:28:17.136] 1. sequential:
[17:28:17.136]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.136]    - tweaked: FALSE
[17:28:17.136]    - call: plan(strategy)
[17:28:17.136] plan(): nbrOfWorkers() = 1
[17:28:17.137] getGlobalsAndPackages() ...
[17:28:17.137] Searching for globals...
[17:28:17.138] - globals found: [3] '{', 'sample', 'x'
[17:28:17.138] Searching for globals ... DONE
[17:28:17.138] Resolving globals: FALSE
[17:28:17.139] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.139] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.139] - globals: [1] 'x'
[17:28:17.140] 
[17:28:17.140] getGlobalsAndPackages() ... DONE
[17:28:17.140] run() for 'Future' ...
[17:28:17.140] - state: 'created'
[17:28:17.140] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.141] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.141] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.141]   - Field: 'label'
[17:28:17.141]   - Field: 'local'
[17:28:17.142]   - Field: 'owner'
[17:28:17.142]   - Field: 'envir'
[17:28:17.142]   - Field: 'packages'
[17:28:17.142]   - Field: 'gc'
[17:28:17.142]   - Field: 'conditions'
[17:28:17.142]   - Field: 'expr'
[17:28:17.143]   - Field: 'uuid'
[17:28:17.143]   - Field: 'seed'
[17:28:17.144]   - Field: 'version'
[17:28:17.144]   - Field: 'result'
[17:28:17.144]   - Field: 'asynchronous'
[17:28:17.144]   - Field: 'calls'
[17:28:17.144]   - Field: 'globals'
[17:28:17.145]   - Field: 'stdout'
[17:28:17.145]   - Field: 'earlySignal'
[17:28:17.145]   - Field: 'lazy'
[17:28:17.145]   - Field: 'state'
[17:28:17.145] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.145] - Launch lazy future ...
[17:28:17.146] Packages needed by the future expression (n = 0): <none>
[17:28:17.146] Packages needed by future strategies (n = 0): <none>
[17:28:17.146] {
[17:28:17.146]     {
[17:28:17.146]         {
[17:28:17.146]             ...future.startTime <- base::Sys.time()
[17:28:17.146]             {
[17:28:17.146]                 {
[17:28:17.146]                   {
[17:28:17.146]                     {
[17:28:17.146]                       base::local({
[17:28:17.146]                         has_future <- base::requireNamespace("future", 
[17:28:17.146]                           quietly = TRUE)
[17:28:17.146]                         if (has_future) {
[17:28:17.146]                           ns <- base::getNamespace("future")
[17:28:17.146]                           version <- ns[[".package"]][["version"]]
[17:28:17.146]                           if (is.null(version)) 
[17:28:17.146]                             version <- utils::packageVersion("future")
[17:28:17.146]                         }
[17:28:17.146]                         else {
[17:28:17.146]                           version <- NULL
[17:28:17.146]                         }
[17:28:17.146]                         if (!has_future || version < "1.8.0") {
[17:28:17.146]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.146]                             "", base::R.version$version.string), 
[17:28:17.146]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:17.146]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.146]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.146]                               "release", "version")], collapse = " "), 
[17:28:17.146]                             hostname = base::Sys.info()[["nodename"]])
[17:28:17.146]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.146]                             info)
[17:28:17.146]                           info <- base::paste(info, collapse = "; ")
[17:28:17.146]                           if (!has_future) {
[17:28:17.146]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.146]                               info)
[17:28:17.146]                           }
[17:28:17.146]                           else {
[17:28:17.146]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.146]                               info, version)
[17:28:17.146]                           }
[17:28:17.146]                           base::stop(msg)
[17:28:17.146]                         }
[17:28:17.146]                       })
[17:28:17.146]                     }
[17:28:17.146]                     ...future.strategy.old <- future::plan("list")
[17:28:17.146]                     options(future.plan = NULL)
[17:28:17.146]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.146]                     future::plan("default", .cleanup = FALSE, 
[17:28:17.146]                       .init = FALSE)
[17:28:17.146]                   }
[17:28:17.146]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:28:17.146]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:28:17.146]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:28:17.146]                 }
[17:28:17.146]                 ...future.workdir <- getwd()
[17:28:17.146]             }
[17:28:17.146]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.146]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.146]         }
[17:28:17.146]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.146]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.146]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.146]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.146]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.146]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.146]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.146]             base::names(...future.oldOptions))
[17:28:17.146]     }
[17:28:17.146]     if (FALSE) {
[17:28:17.146]     }
[17:28:17.146]     else {
[17:28:17.146]         if (TRUE) {
[17:28:17.146]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.146]                 open = "w")
[17:28:17.146]         }
[17:28:17.146]         else {
[17:28:17.146]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.146]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.146]         }
[17:28:17.146]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.146]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.146]             base::sink(type = "output", split = FALSE)
[17:28:17.146]             base::close(...future.stdout)
[17:28:17.146]         }, add = TRUE)
[17:28:17.146]     }
[17:28:17.146]     ...future.frame <- base::sys.nframe()
[17:28:17.146]     ...future.conditions <- base::list()
[17:28:17.146]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.146]     if (FALSE) {
[17:28:17.146]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.146]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.146]     }
[17:28:17.146]     ...future.result <- base::tryCatch({
[17:28:17.146]         base::withCallingHandlers({
[17:28:17.146]             ...future.value <- base::withVisible(base::local({
[17:28:17.146]                 sample(x, size = 1L)
[17:28:17.146]             }))
[17:28:17.146]             future::FutureResult(value = ...future.value$value, 
[17:28:17.146]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.146]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.146]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.146]                     ...future.globalenv.names))
[17:28:17.146]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.146]         }, condition = base::local({
[17:28:17.146]             c <- base::c
[17:28:17.146]             inherits <- base::inherits
[17:28:17.146]             invokeRestart <- base::invokeRestart
[17:28:17.146]             length <- base::length
[17:28:17.146]             list <- base::list
[17:28:17.146]             seq.int <- base::seq.int
[17:28:17.146]             signalCondition <- base::signalCondition
[17:28:17.146]             sys.calls <- base::sys.calls
[17:28:17.146]             `[[` <- base::`[[`
[17:28:17.146]             `+` <- base::`+`
[17:28:17.146]             `<<-` <- base::`<<-`
[17:28:17.146]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.146]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.146]                   3L)]
[17:28:17.146]             }
[17:28:17.146]             function(cond) {
[17:28:17.146]                 is_error <- inherits(cond, "error")
[17:28:17.146]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.146]                   NULL)
[17:28:17.146]                 if (is_error) {
[17:28:17.146]                   sessionInformation <- function() {
[17:28:17.146]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.146]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.146]                       search = base::search(), system = base::Sys.info())
[17:28:17.146]                   }
[17:28:17.146]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.146]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.146]                     cond$call), session = sessionInformation(), 
[17:28:17.146]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.146]                   signalCondition(cond)
[17:28:17.146]                 }
[17:28:17.146]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.146]                 "immediateCondition"))) {
[17:28:17.146]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.146]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.146]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.146]                   if (TRUE && !signal) {
[17:28:17.146]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.146]                     {
[17:28:17.146]                       inherits <- base::inherits
[17:28:17.146]                       invokeRestart <- base::invokeRestart
[17:28:17.146]                       is.null <- base::is.null
[17:28:17.146]                       muffled <- FALSE
[17:28:17.146]                       if (inherits(cond, "message")) {
[17:28:17.146]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.146]                         if (muffled) 
[17:28:17.146]                           invokeRestart("muffleMessage")
[17:28:17.146]                       }
[17:28:17.146]                       else if (inherits(cond, "warning")) {
[17:28:17.146]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.146]                         if (muffled) 
[17:28:17.146]                           invokeRestart("muffleWarning")
[17:28:17.146]                       }
[17:28:17.146]                       else if (inherits(cond, "condition")) {
[17:28:17.146]                         if (!is.null(pattern)) {
[17:28:17.146]                           computeRestarts <- base::computeRestarts
[17:28:17.146]                           grepl <- base::grepl
[17:28:17.146]                           restarts <- computeRestarts(cond)
[17:28:17.146]                           for (restart in restarts) {
[17:28:17.146]                             name <- restart$name
[17:28:17.146]                             if (is.null(name)) 
[17:28:17.146]                               next
[17:28:17.146]                             if (!grepl(pattern, name)) 
[17:28:17.146]                               next
[17:28:17.146]                             invokeRestart(restart)
[17:28:17.146]                             muffled <- TRUE
[17:28:17.146]                             break
[17:28:17.146]                           }
[17:28:17.146]                         }
[17:28:17.146]                       }
[17:28:17.146]                       invisible(muffled)
[17:28:17.146]                     }
[17:28:17.146]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.146]                   }
[17:28:17.146]                 }
[17:28:17.146]                 else {
[17:28:17.146]                   if (TRUE) {
[17:28:17.146]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.146]                     {
[17:28:17.146]                       inherits <- base::inherits
[17:28:17.146]                       invokeRestart <- base::invokeRestart
[17:28:17.146]                       is.null <- base::is.null
[17:28:17.146]                       muffled <- FALSE
[17:28:17.146]                       if (inherits(cond, "message")) {
[17:28:17.146]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.146]                         if (muffled) 
[17:28:17.146]                           invokeRestart("muffleMessage")
[17:28:17.146]                       }
[17:28:17.146]                       else if (inherits(cond, "warning")) {
[17:28:17.146]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.146]                         if (muffled) 
[17:28:17.146]                           invokeRestart("muffleWarning")
[17:28:17.146]                       }
[17:28:17.146]                       else if (inherits(cond, "condition")) {
[17:28:17.146]                         if (!is.null(pattern)) {
[17:28:17.146]                           computeRestarts <- base::computeRestarts
[17:28:17.146]                           grepl <- base::grepl
[17:28:17.146]                           restarts <- computeRestarts(cond)
[17:28:17.146]                           for (restart in restarts) {
[17:28:17.146]                             name <- restart$name
[17:28:17.146]                             if (is.null(name)) 
[17:28:17.146]                               next
[17:28:17.146]                             if (!grepl(pattern, name)) 
[17:28:17.146]                               next
[17:28:17.146]                             invokeRestart(restart)
[17:28:17.146]                             muffled <- TRUE
[17:28:17.146]                             break
[17:28:17.146]                           }
[17:28:17.146]                         }
[17:28:17.146]                       }
[17:28:17.146]                       invisible(muffled)
[17:28:17.146]                     }
[17:28:17.146]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.146]                   }
[17:28:17.146]                 }
[17:28:17.146]             }
[17:28:17.146]         }))
[17:28:17.146]     }, error = function(ex) {
[17:28:17.146]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.146]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.146]                 ...future.rng), started = ...future.startTime, 
[17:28:17.146]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.146]             version = "1.8"), class = "FutureResult")
[17:28:17.146]     }, finally = {
[17:28:17.146]         if (!identical(...future.workdir, getwd())) 
[17:28:17.146]             setwd(...future.workdir)
[17:28:17.146]         {
[17:28:17.146]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.146]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.146]             }
[17:28:17.146]             base::options(...future.oldOptions)
[17:28:17.146]             if (.Platform$OS.type == "windows") {
[17:28:17.146]                 old_names <- names(...future.oldEnvVars)
[17:28:17.146]                 envs <- base::Sys.getenv()
[17:28:17.146]                 names <- names(envs)
[17:28:17.146]                 common <- intersect(names, old_names)
[17:28:17.146]                 added <- setdiff(names, old_names)
[17:28:17.146]                 removed <- setdiff(old_names, names)
[17:28:17.146]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.146]                   envs[common]]
[17:28:17.146]                 NAMES <- toupper(changed)
[17:28:17.146]                 args <- list()
[17:28:17.146]                 for (kk in seq_along(NAMES)) {
[17:28:17.146]                   name <- changed[[kk]]
[17:28:17.146]                   NAME <- NAMES[[kk]]
[17:28:17.146]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.146]                     next
[17:28:17.146]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.146]                 }
[17:28:17.146]                 NAMES <- toupper(added)
[17:28:17.146]                 for (kk in seq_along(NAMES)) {
[17:28:17.146]                   name <- added[[kk]]
[17:28:17.146]                   NAME <- NAMES[[kk]]
[17:28:17.146]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.146]                     next
[17:28:17.146]                   args[[name]] <- ""
[17:28:17.146]                 }
[17:28:17.146]                 NAMES <- toupper(removed)
[17:28:17.146]                 for (kk in seq_along(NAMES)) {
[17:28:17.146]                   name <- removed[[kk]]
[17:28:17.146]                   NAME <- NAMES[[kk]]
[17:28:17.146]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.146]                     next
[17:28:17.146]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.146]                 }
[17:28:17.146]                 if (length(args) > 0) 
[17:28:17.146]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.146]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.146]             }
[17:28:17.146]             else {
[17:28:17.146]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.146]             }
[17:28:17.146]             {
[17:28:17.146]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.146]                   0L) {
[17:28:17.146]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.146]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.146]                   base::options(opts)
[17:28:17.146]                 }
[17:28:17.146]                 {
[17:28:17.146]                   {
[17:28:17.146]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:17.146]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:17.146]                     -1344458670L), envir = base::globalenv(), 
[17:28:17.146]                       inherits = FALSE)
[17:28:17.146]                     NULL
[17:28:17.146]                   }
[17:28:17.146]                   options(future.plan = NULL)
[17:28:17.146]                   if (is.na(NA_character_)) 
[17:28:17.146]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.146]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.146]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.146]                     .init = FALSE)
[17:28:17.146]                 }
[17:28:17.146]             }
[17:28:17.146]         }
[17:28:17.146]     })
[17:28:17.146]     if (TRUE) {
[17:28:17.146]         base::sink(type = "output", split = FALSE)
[17:28:17.146]         if (TRUE) {
[17:28:17.146]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.146]         }
[17:28:17.146]         else {
[17:28:17.146]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.146]         }
[17:28:17.146]         base::close(...future.stdout)
[17:28:17.146]         ...future.stdout <- NULL
[17:28:17.146]     }
[17:28:17.146]     ...future.result$conditions <- ...future.conditions
[17:28:17.146]     ...future.result$finished <- base::Sys.time()
[17:28:17.146]     ...future.result
[17:28:17.146] }
[17:28:17.150] assign_globals() ...
[17:28:17.150] List of 1
[17:28:17.150]  $ x: int [1:4] 0 1 2 3
[17:28:17.150]  - attr(*, "where")=List of 1
[17:28:17.150]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.150]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.150]  - attr(*, "resolved")= logi FALSE
[17:28:17.150]  - attr(*, "total_size")= num 64
[17:28:17.150]  - attr(*, "already-done")= logi TRUE
[17:28:17.153] - copied 'x' to environment
[17:28:17.153] assign_globals() ... done
[17:28:17.154] plan(): Setting new future strategy stack:
[17:28:17.154] List of future strategies:
[17:28:17.154] 1. sequential:
[17:28:17.154]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.154]    - tweaked: FALSE
[17:28:17.154]    - call: NULL
[17:28:17.154] plan(): nbrOfWorkers() = 1
[17:28:17.156] plan(): Setting new future strategy stack:
[17:28:17.156] List of future strategies:
[17:28:17.156] 1. sequential:
[17:28:17.156]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.156]    - tweaked: FALSE
[17:28:17.156]    - call: plan(strategy)
[17:28:17.156] plan(): nbrOfWorkers() = 1
[17:28:17.157] SequentialFuture started (and completed)
[17:28:17.157] - Launch lazy future ... done
[17:28:17.157] run() for 'SequentialFuture' ... done
[17:28:17.157] getGlobalsAndPackages() ...
[17:28:17.157] Searching for globals...
[17:28:17.158] - globals found: [3] '{', 'sample', 'x'
[17:28:17.159] Searching for globals ... DONE
[17:28:17.159] Resolving globals: FALSE
[17:28:17.159] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.160] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.160] - globals: [1] 'x'
[17:28:17.160] 
[17:28:17.160] getGlobalsAndPackages() ... DONE
[17:28:17.161] run() for 'Future' ...
[17:28:17.161] - state: 'created'
[17:28:17.161] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.161] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.162] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.162]   - Field: 'label'
[17:28:17.162]   - Field: 'local'
[17:28:17.162]   - Field: 'owner'
[17:28:17.162]   - Field: 'envir'
[17:28:17.162]   - Field: 'packages'
[17:28:17.163]   - Field: 'gc'
[17:28:17.163]   - Field: 'conditions'
[17:28:17.163]   - Field: 'expr'
[17:28:17.163]   - Field: 'uuid'
[17:28:17.163]   - Field: 'seed'
[17:28:17.163]   - Field: 'version'
[17:28:17.164]   - Field: 'result'
[17:28:17.164]   - Field: 'asynchronous'
[17:28:17.164]   - Field: 'calls'
[17:28:17.164]   - Field: 'globals'
[17:28:17.164]   - Field: 'stdout'
[17:28:17.164]   - Field: 'earlySignal'
[17:28:17.165]   - Field: 'lazy'
[17:28:17.165]   - Field: 'state'
[17:28:17.165] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.165] - Launch lazy future ...
[17:28:17.165] Packages needed by the future expression (n = 0): <none>
[17:28:17.166] Packages needed by future strategies (n = 0): <none>
[17:28:17.166] {
[17:28:17.166]     {
[17:28:17.166]         {
[17:28:17.166]             ...future.startTime <- base::Sys.time()
[17:28:17.166]             {
[17:28:17.166]                 {
[17:28:17.166]                   {
[17:28:17.166]                     {
[17:28:17.166]                       base::local({
[17:28:17.166]                         has_future <- base::requireNamespace("future", 
[17:28:17.166]                           quietly = TRUE)
[17:28:17.166]                         if (has_future) {
[17:28:17.166]                           ns <- base::getNamespace("future")
[17:28:17.166]                           version <- ns[[".package"]][["version"]]
[17:28:17.166]                           if (is.null(version)) 
[17:28:17.166]                             version <- utils::packageVersion("future")
[17:28:17.166]                         }
[17:28:17.166]                         else {
[17:28:17.166]                           version <- NULL
[17:28:17.166]                         }
[17:28:17.166]                         if (!has_future || version < "1.8.0") {
[17:28:17.166]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.166]                             "", base::R.version$version.string), 
[17:28:17.166]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:17.166]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.166]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.166]                               "release", "version")], collapse = " "), 
[17:28:17.166]                             hostname = base::Sys.info()[["nodename"]])
[17:28:17.166]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.166]                             info)
[17:28:17.166]                           info <- base::paste(info, collapse = "; ")
[17:28:17.166]                           if (!has_future) {
[17:28:17.166]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.166]                               info)
[17:28:17.166]                           }
[17:28:17.166]                           else {
[17:28:17.166]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.166]                               info, version)
[17:28:17.166]                           }
[17:28:17.166]                           base::stop(msg)
[17:28:17.166]                         }
[17:28:17.166]                       })
[17:28:17.166]                     }
[17:28:17.166]                     ...future.strategy.old <- future::plan("list")
[17:28:17.166]                     options(future.plan = NULL)
[17:28:17.166]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.166]                     future::plan("default", .cleanup = FALSE, 
[17:28:17.166]                       .init = FALSE)
[17:28:17.166]                   }
[17:28:17.166]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:28:17.166]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:28:17.166]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:28:17.166]                 }
[17:28:17.166]                 ...future.workdir <- getwd()
[17:28:17.166]             }
[17:28:17.166]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.166]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.166]         }
[17:28:17.166]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.166]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.166]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.166]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.166]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.166]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.166]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.166]             base::names(...future.oldOptions))
[17:28:17.166]     }
[17:28:17.166]     if (FALSE) {
[17:28:17.166]     }
[17:28:17.166]     else {
[17:28:17.166]         if (TRUE) {
[17:28:17.166]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.166]                 open = "w")
[17:28:17.166]         }
[17:28:17.166]         else {
[17:28:17.166]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.166]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.166]         }
[17:28:17.166]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.166]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.166]             base::sink(type = "output", split = FALSE)
[17:28:17.166]             base::close(...future.stdout)
[17:28:17.166]         }, add = TRUE)
[17:28:17.166]     }
[17:28:17.166]     ...future.frame <- base::sys.nframe()
[17:28:17.166]     ...future.conditions <- base::list()
[17:28:17.166]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.166]     if (FALSE) {
[17:28:17.166]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.166]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.166]     }
[17:28:17.166]     ...future.result <- base::tryCatch({
[17:28:17.166]         base::withCallingHandlers({
[17:28:17.166]             ...future.value <- base::withVisible(base::local({
[17:28:17.166]                 sample(x, size = 1L)
[17:28:17.166]             }))
[17:28:17.166]             future::FutureResult(value = ...future.value$value, 
[17:28:17.166]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.166]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.166]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.166]                     ...future.globalenv.names))
[17:28:17.166]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.166]         }, condition = base::local({
[17:28:17.166]             c <- base::c
[17:28:17.166]             inherits <- base::inherits
[17:28:17.166]             invokeRestart <- base::invokeRestart
[17:28:17.166]             length <- base::length
[17:28:17.166]             list <- base::list
[17:28:17.166]             seq.int <- base::seq.int
[17:28:17.166]             signalCondition <- base::signalCondition
[17:28:17.166]             sys.calls <- base::sys.calls
[17:28:17.166]             `[[` <- base::`[[`
[17:28:17.166]             `+` <- base::`+`
[17:28:17.166]             `<<-` <- base::`<<-`
[17:28:17.166]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.166]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.166]                   3L)]
[17:28:17.166]             }
[17:28:17.166]             function(cond) {
[17:28:17.166]                 is_error <- inherits(cond, "error")
[17:28:17.166]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.166]                   NULL)
[17:28:17.166]                 if (is_error) {
[17:28:17.166]                   sessionInformation <- function() {
[17:28:17.166]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.166]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.166]                       search = base::search(), system = base::Sys.info())
[17:28:17.166]                   }
[17:28:17.166]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.166]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.166]                     cond$call), session = sessionInformation(), 
[17:28:17.166]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.166]                   signalCondition(cond)
[17:28:17.166]                 }
[17:28:17.166]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.166]                 "immediateCondition"))) {
[17:28:17.166]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.166]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.166]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.166]                   if (TRUE && !signal) {
[17:28:17.166]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.166]                     {
[17:28:17.166]                       inherits <- base::inherits
[17:28:17.166]                       invokeRestart <- base::invokeRestart
[17:28:17.166]                       is.null <- base::is.null
[17:28:17.166]                       muffled <- FALSE
[17:28:17.166]                       if (inherits(cond, "message")) {
[17:28:17.166]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.166]                         if (muffled) 
[17:28:17.166]                           invokeRestart("muffleMessage")
[17:28:17.166]                       }
[17:28:17.166]                       else if (inherits(cond, "warning")) {
[17:28:17.166]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.166]                         if (muffled) 
[17:28:17.166]                           invokeRestart("muffleWarning")
[17:28:17.166]                       }
[17:28:17.166]                       else if (inherits(cond, "condition")) {
[17:28:17.166]                         if (!is.null(pattern)) {
[17:28:17.166]                           computeRestarts <- base::computeRestarts
[17:28:17.166]                           grepl <- base::grepl
[17:28:17.166]                           restarts <- computeRestarts(cond)
[17:28:17.166]                           for (restart in restarts) {
[17:28:17.166]                             name <- restart$name
[17:28:17.166]                             if (is.null(name)) 
[17:28:17.166]                               next
[17:28:17.166]                             if (!grepl(pattern, name)) 
[17:28:17.166]                               next
[17:28:17.166]                             invokeRestart(restart)
[17:28:17.166]                             muffled <- TRUE
[17:28:17.166]                             break
[17:28:17.166]                           }
[17:28:17.166]                         }
[17:28:17.166]                       }
[17:28:17.166]                       invisible(muffled)
[17:28:17.166]                     }
[17:28:17.166]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.166]                   }
[17:28:17.166]                 }
[17:28:17.166]                 else {
[17:28:17.166]                   if (TRUE) {
[17:28:17.166]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.166]                     {
[17:28:17.166]                       inherits <- base::inherits
[17:28:17.166]                       invokeRestart <- base::invokeRestart
[17:28:17.166]                       is.null <- base::is.null
[17:28:17.166]                       muffled <- FALSE
[17:28:17.166]                       if (inherits(cond, "message")) {
[17:28:17.166]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.166]                         if (muffled) 
[17:28:17.166]                           invokeRestart("muffleMessage")
[17:28:17.166]                       }
[17:28:17.166]                       else if (inherits(cond, "warning")) {
[17:28:17.166]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.166]                         if (muffled) 
[17:28:17.166]                           invokeRestart("muffleWarning")
[17:28:17.166]                       }
[17:28:17.166]                       else if (inherits(cond, "condition")) {
[17:28:17.166]                         if (!is.null(pattern)) {
[17:28:17.166]                           computeRestarts <- base::computeRestarts
[17:28:17.166]                           grepl <- base::grepl
[17:28:17.166]                           restarts <- computeRestarts(cond)
[17:28:17.166]                           for (restart in restarts) {
[17:28:17.166]                             name <- restart$name
[17:28:17.166]                             if (is.null(name)) 
[17:28:17.166]                               next
[17:28:17.166]                             if (!grepl(pattern, name)) 
[17:28:17.166]                               next
[17:28:17.166]                             invokeRestart(restart)
[17:28:17.166]                             muffled <- TRUE
[17:28:17.166]                             break
[17:28:17.166]                           }
[17:28:17.166]                         }
[17:28:17.166]                       }
[17:28:17.166]                       invisible(muffled)
[17:28:17.166]                     }
[17:28:17.166]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.166]                   }
[17:28:17.166]                 }
[17:28:17.166]             }
[17:28:17.166]         }))
[17:28:17.166]     }, error = function(ex) {
[17:28:17.166]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.166]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.166]                 ...future.rng), started = ...future.startTime, 
[17:28:17.166]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.166]             version = "1.8"), class = "FutureResult")
[17:28:17.166]     }, finally = {
[17:28:17.166]         if (!identical(...future.workdir, getwd())) 
[17:28:17.166]             setwd(...future.workdir)
[17:28:17.166]         {
[17:28:17.166]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.166]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.166]             }
[17:28:17.166]             base::options(...future.oldOptions)
[17:28:17.166]             if (.Platform$OS.type == "windows") {
[17:28:17.166]                 old_names <- names(...future.oldEnvVars)
[17:28:17.166]                 envs <- base::Sys.getenv()
[17:28:17.166]                 names <- names(envs)
[17:28:17.166]                 common <- intersect(names, old_names)
[17:28:17.166]                 added <- setdiff(names, old_names)
[17:28:17.166]                 removed <- setdiff(old_names, names)
[17:28:17.166]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.166]                   envs[common]]
[17:28:17.166]                 NAMES <- toupper(changed)
[17:28:17.166]                 args <- list()
[17:28:17.166]                 for (kk in seq_along(NAMES)) {
[17:28:17.166]                   name <- changed[[kk]]
[17:28:17.166]                   NAME <- NAMES[[kk]]
[17:28:17.166]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.166]                     next
[17:28:17.166]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.166]                 }
[17:28:17.166]                 NAMES <- toupper(added)
[17:28:17.166]                 for (kk in seq_along(NAMES)) {
[17:28:17.166]                   name <- added[[kk]]
[17:28:17.166]                   NAME <- NAMES[[kk]]
[17:28:17.166]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.166]                     next
[17:28:17.166]                   args[[name]] <- ""
[17:28:17.166]                 }
[17:28:17.166]                 NAMES <- toupper(removed)
[17:28:17.166]                 for (kk in seq_along(NAMES)) {
[17:28:17.166]                   name <- removed[[kk]]
[17:28:17.166]                   NAME <- NAMES[[kk]]
[17:28:17.166]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.166]                     next
[17:28:17.166]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.166]                 }
[17:28:17.166]                 if (length(args) > 0) 
[17:28:17.166]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.166]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.166]             }
[17:28:17.166]             else {
[17:28:17.166]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.166]             }
[17:28:17.166]             {
[17:28:17.166]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.166]                   0L) {
[17:28:17.166]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.166]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.166]                   base::options(opts)
[17:28:17.166]                 }
[17:28:17.166]                 {
[17:28:17.166]                   {
[17:28:17.166]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:17.166]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:17.166]                     -1344458670L), envir = base::globalenv(), 
[17:28:17.166]                       inherits = FALSE)
[17:28:17.166]                     NULL
[17:28:17.166]                   }
[17:28:17.166]                   options(future.plan = NULL)
[17:28:17.166]                   if (is.na(NA_character_)) 
[17:28:17.166]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.166]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.166]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.166]                     .init = FALSE)
[17:28:17.166]                 }
[17:28:17.166]             }
[17:28:17.166]         }
[17:28:17.166]     })
[17:28:17.166]     if (TRUE) {
[17:28:17.166]         base::sink(type = "output", split = FALSE)
[17:28:17.166]         if (TRUE) {
[17:28:17.166]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.166]         }
[17:28:17.166]         else {
[17:28:17.166]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.166]         }
[17:28:17.166]         base::close(...future.stdout)
[17:28:17.166]         ...future.stdout <- NULL
[17:28:17.166]     }
[17:28:17.166]     ...future.result$conditions <- ...future.conditions
[17:28:17.166]     ...future.result$finished <- base::Sys.time()
[17:28:17.166]     ...future.result
[17:28:17.166] }
[17:28:17.170] assign_globals() ...
[17:28:17.170] List of 1
[17:28:17.170]  $ x: int [1:4] 0 1 2 3
[17:28:17.170]  - attr(*, "where")=List of 1
[17:28:17.170]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.170]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.170]  - attr(*, "resolved")= logi FALSE
[17:28:17.170]  - attr(*, "total_size")= num 64
[17:28:17.170]  - attr(*, "already-done")= logi TRUE
[17:28:17.173] - copied 'x' to environment
[17:28:17.173] assign_globals() ... done
[17:28:17.174] plan(): Setting new future strategy stack:
[17:28:17.174] List of future strategies:
[17:28:17.174] 1. sequential:
[17:28:17.174]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.174]    - tweaked: FALSE
[17:28:17.174]    - call: NULL
[17:28:17.174] plan(): nbrOfWorkers() = 1
[17:28:17.175] plan(): Setting new future strategy stack:
[17:28:17.176] List of future strategies:
[17:28:17.176] 1. sequential:
[17:28:17.176]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.176]    - tweaked: FALSE
[17:28:17.176]    - call: plan(strategy)
[17:28:17.176] plan(): nbrOfWorkers() = 1
[17:28:17.177] SequentialFuture started (and completed)
[17:28:17.177] - Launch lazy future ... done
[17:28:17.177] run() for 'SequentialFuture' ... done
[17:28:17.177] getGlobalsAndPackages() ...
[17:28:17.177] Searching for globals...
[17:28:17.179] - globals found: [3] '{', 'sample', 'x'
[17:28:17.179] Searching for globals ... DONE
[17:28:17.180] Resolving globals: FALSE
[17:28:17.180] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.181] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.181] - globals: [1] 'x'
[17:28:17.181] 
[17:28:17.181] getGlobalsAndPackages() ... DONE
[17:28:17.181] run() for 'Future' ...
[17:28:17.182] - state: 'created'
[17:28:17.182] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.182] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.182] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.183]   - Field: 'label'
[17:28:17.183]   - Field: 'local'
[17:28:17.183]   - Field: 'owner'
[17:28:17.183]   - Field: 'envir'
[17:28:17.183]   - Field: 'packages'
[17:28:17.183]   - Field: 'gc'
[17:28:17.184]   - Field: 'conditions'
[17:28:17.184]   - Field: 'expr'
[17:28:17.184]   - Field: 'uuid'
[17:28:17.184]   - Field: 'seed'
[17:28:17.184]   - Field: 'version'
[17:28:17.184]   - Field: 'result'
[17:28:17.185]   - Field: 'asynchronous'
[17:28:17.185]   - Field: 'calls'
[17:28:17.185]   - Field: 'globals'
[17:28:17.185]   - Field: 'stdout'
[17:28:17.185]   - Field: 'earlySignal'
[17:28:17.185]   - Field: 'lazy'
[17:28:17.186]   - Field: 'state'
[17:28:17.186] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.186] - Launch lazy future ...
[17:28:17.186] Packages needed by the future expression (n = 0): <none>
[17:28:17.186] Packages needed by future strategies (n = 0): <none>
[17:28:17.187] {
[17:28:17.187]     {
[17:28:17.187]         {
[17:28:17.187]             ...future.startTime <- base::Sys.time()
[17:28:17.187]             {
[17:28:17.187]                 {
[17:28:17.187]                   {
[17:28:17.187]                     {
[17:28:17.187]                       base::local({
[17:28:17.187]                         has_future <- base::requireNamespace("future", 
[17:28:17.187]                           quietly = TRUE)
[17:28:17.187]                         if (has_future) {
[17:28:17.187]                           ns <- base::getNamespace("future")
[17:28:17.187]                           version <- ns[[".package"]][["version"]]
[17:28:17.187]                           if (is.null(version)) 
[17:28:17.187]                             version <- utils::packageVersion("future")
[17:28:17.187]                         }
[17:28:17.187]                         else {
[17:28:17.187]                           version <- NULL
[17:28:17.187]                         }
[17:28:17.187]                         if (!has_future || version < "1.8.0") {
[17:28:17.187]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.187]                             "", base::R.version$version.string), 
[17:28:17.187]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:17.187]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.187]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.187]                               "release", "version")], collapse = " "), 
[17:28:17.187]                             hostname = base::Sys.info()[["nodename"]])
[17:28:17.187]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.187]                             info)
[17:28:17.187]                           info <- base::paste(info, collapse = "; ")
[17:28:17.187]                           if (!has_future) {
[17:28:17.187]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.187]                               info)
[17:28:17.187]                           }
[17:28:17.187]                           else {
[17:28:17.187]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.187]                               info, version)
[17:28:17.187]                           }
[17:28:17.187]                           base::stop(msg)
[17:28:17.187]                         }
[17:28:17.187]                       })
[17:28:17.187]                     }
[17:28:17.187]                     ...future.strategy.old <- future::plan("list")
[17:28:17.187]                     options(future.plan = NULL)
[17:28:17.187]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.187]                     future::plan("default", .cleanup = FALSE, 
[17:28:17.187]                       .init = FALSE)
[17:28:17.187]                   }
[17:28:17.187]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:28:17.187]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:28:17.187]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:28:17.187]                 }
[17:28:17.187]                 ...future.workdir <- getwd()
[17:28:17.187]             }
[17:28:17.187]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.187]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.187]         }
[17:28:17.187]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.187]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.187]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.187]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.187]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.187]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.187]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.187]             base::names(...future.oldOptions))
[17:28:17.187]     }
[17:28:17.187]     if (FALSE) {
[17:28:17.187]     }
[17:28:17.187]     else {
[17:28:17.187]         if (TRUE) {
[17:28:17.187]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.187]                 open = "w")
[17:28:17.187]         }
[17:28:17.187]         else {
[17:28:17.187]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.187]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.187]         }
[17:28:17.187]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.187]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.187]             base::sink(type = "output", split = FALSE)
[17:28:17.187]             base::close(...future.stdout)
[17:28:17.187]         }, add = TRUE)
[17:28:17.187]     }
[17:28:17.187]     ...future.frame <- base::sys.nframe()
[17:28:17.187]     ...future.conditions <- base::list()
[17:28:17.187]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.187]     if (FALSE) {
[17:28:17.187]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.187]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.187]     }
[17:28:17.187]     ...future.result <- base::tryCatch({
[17:28:17.187]         base::withCallingHandlers({
[17:28:17.187]             ...future.value <- base::withVisible(base::local({
[17:28:17.187]                 sample(x, size = 1L)
[17:28:17.187]             }))
[17:28:17.187]             future::FutureResult(value = ...future.value$value, 
[17:28:17.187]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.187]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.187]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.187]                     ...future.globalenv.names))
[17:28:17.187]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.187]         }, condition = base::local({
[17:28:17.187]             c <- base::c
[17:28:17.187]             inherits <- base::inherits
[17:28:17.187]             invokeRestart <- base::invokeRestart
[17:28:17.187]             length <- base::length
[17:28:17.187]             list <- base::list
[17:28:17.187]             seq.int <- base::seq.int
[17:28:17.187]             signalCondition <- base::signalCondition
[17:28:17.187]             sys.calls <- base::sys.calls
[17:28:17.187]             `[[` <- base::`[[`
[17:28:17.187]             `+` <- base::`+`
[17:28:17.187]             `<<-` <- base::`<<-`
[17:28:17.187]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.187]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.187]                   3L)]
[17:28:17.187]             }
[17:28:17.187]             function(cond) {
[17:28:17.187]                 is_error <- inherits(cond, "error")
[17:28:17.187]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.187]                   NULL)
[17:28:17.187]                 if (is_error) {
[17:28:17.187]                   sessionInformation <- function() {
[17:28:17.187]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.187]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.187]                       search = base::search(), system = base::Sys.info())
[17:28:17.187]                   }
[17:28:17.187]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.187]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.187]                     cond$call), session = sessionInformation(), 
[17:28:17.187]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.187]                   signalCondition(cond)
[17:28:17.187]                 }
[17:28:17.187]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.187]                 "immediateCondition"))) {
[17:28:17.187]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.187]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.187]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.187]                   if (TRUE && !signal) {
[17:28:17.187]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.187]                     {
[17:28:17.187]                       inherits <- base::inherits
[17:28:17.187]                       invokeRestart <- base::invokeRestart
[17:28:17.187]                       is.null <- base::is.null
[17:28:17.187]                       muffled <- FALSE
[17:28:17.187]                       if (inherits(cond, "message")) {
[17:28:17.187]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.187]                         if (muffled) 
[17:28:17.187]                           invokeRestart("muffleMessage")
[17:28:17.187]                       }
[17:28:17.187]                       else if (inherits(cond, "warning")) {
[17:28:17.187]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.187]                         if (muffled) 
[17:28:17.187]                           invokeRestart("muffleWarning")
[17:28:17.187]                       }
[17:28:17.187]                       else if (inherits(cond, "condition")) {
[17:28:17.187]                         if (!is.null(pattern)) {
[17:28:17.187]                           computeRestarts <- base::computeRestarts
[17:28:17.187]                           grepl <- base::grepl
[17:28:17.187]                           restarts <- computeRestarts(cond)
[17:28:17.187]                           for (restart in restarts) {
[17:28:17.187]                             name <- restart$name
[17:28:17.187]                             if (is.null(name)) 
[17:28:17.187]                               next
[17:28:17.187]                             if (!grepl(pattern, name)) 
[17:28:17.187]                               next
[17:28:17.187]                             invokeRestart(restart)
[17:28:17.187]                             muffled <- TRUE
[17:28:17.187]                             break
[17:28:17.187]                           }
[17:28:17.187]                         }
[17:28:17.187]                       }
[17:28:17.187]                       invisible(muffled)
[17:28:17.187]                     }
[17:28:17.187]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.187]                   }
[17:28:17.187]                 }
[17:28:17.187]                 else {
[17:28:17.187]                   if (TRUE) {
[17:28:17.187]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.187]                     {
[17:28:17.187]                       inherits <- base::inherits
[17:28:17.187]                       invokeRestart <- base::invokeRestart
[17:28:17.187]                       is.null <- base::is.null
[17:28:17.187]                       muffled <- FALSE
[17:28:17.187]                       if (inherits(cond, "message")) {
[17:28:17.187]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.187]                         if (muffled) 
[17:28:17.187]                           invokeRestart("muffleMessage")
[17:28:17.187]                       }
[17:28:17.187]                       else if (inherits(cond, "warning")) {
[17:28:17.187]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.187]                         if (muffled) 
[17:28:17.187]                           invokeRestart("muffleWarning")
[17:28:17.187]                       }
[17:28:17.187]                       else if (inherits(cond, "condition")) {
[17:28:17.187]                         if (!is.null(pattern)) {
[17:28:17.187]                           computeRestarts <- base::computeRestarts
[17:28:17.187]                           grepl <- base::grepl
[17:28:17.187]                           restarts <- computeRestarts(cond)
[17:28:17.187]                           for (restart in restarts) {
[17:28:17.187]                             name <- restart$name
[17:28:17.187]                             if (is.null(name)) 
[17:28:17.187]                               next
[17:28:17.187]                             if (!grepl(pattern, name)) 
[17:28:17.187]                               next
[17:28:17.187]                             invokeRestart(restart)
[17:28:17.187]                             muffled <- TRUE
[17:28:17.187]                             break
[17:28:17.187]                           }
[17:28:17.187]                         }
[17:28:17.187]                       }
[17:28:17.187]                       invisible(muffled)
[17:28:17.187]                     }
[17:28:17.187]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.187]                   }
[17:28:17.187]                 }
[17:28:17.187]             }
[17:28:17.187]         }))
[17:28:17.187]     }, error = function(ex) {
[17:28:17.187]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.187]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.187]                 ...future.rng), started = ...future.startTime, 
[17:28:17.187]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.187]             version = "1.8"), class = "FutureResult")
[17:28:17.187]     }, finally = {
[17:28:17.187]         if (!identical(...future.workdir, getwd())) 
[17:28:17.187]             setwd(...future.workdir)
[17:28:17.187]         {
[17:28:17.187]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.187]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.187]             }
[17:28:17.187]             base::options(...future.oldOptions)
[17:28:17.187]             if (.Platform$OS.type == "windows") {
[17:28:17.187]                 old_names <- names(...future.oldEnvVars)
[17:28:17.187]                 envs <- base::Sys.getenv()
[17:28:17.187]                 names <- names(envs)
[17:28:17.187]                 common <- intersect(names, old_names)
[17:28:17.187]                 added <- setdiff(names, old_names)
[17:28:17.187]                 removed <- setdiff(old_names, names)
[17:28:17.187]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.187]                   envs[common]]
[17:28:17.187]                 NAMES <- toupper(changed)
[17:28:17.187]                 args <- list()
[17:28:17.187]                 for (kk in seq_along(NAMES)) {
[17:28:17.187]                   name <- changed[[kk]]
[17:28:17.187]                   NAME <- NAMES[[kk]]
[17:28:17.187]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.187]                     next
[17:28:17.187]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.187]                 }
[17:28:17.187]                 NAMES <- toupper(added)
[17:28:17.187]                 for (kk in seq_along(NAMES)) {
[17:28:17.187]                   name <- added[[kk]]
[17:28:17.187]                   NAME <- NAMES[[kk]]
[17:28:17.187]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.187]                     next
[17:28:17.187]                   args[[name]] <- ""
[17:28:17.187]                 }
[17:28:17.187]                 NAMES <- toupper(removed)
[17:28:17.187]                 for (kk in seq_along(NAMES)) {
[17:28:17.187]                   name <- removed[[kk]]
[17:28:17.187]                   NAME <- NAMES[[kk]]
[17:28:17.187]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.187]                     next
[17:28:17.187]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.187]                 }
[17:28:17.187]                 if (length(args) > 0) 
[17:28:17.187]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.187]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.187]             }
[17:28:17.187]             else {
[17:28:17.187]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.187]             }
[17:28:17.187]             {
[17:28:17.187]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.187]                   0L) {
[17:28:17.187]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.187]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.187]                   base::options(opts)
[17:28:17.187]                 }
[17:28:17.187]                 {
[17:28:17.187]                   {
[17:28:17.187]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:17.187]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:17.187]                     -1344458670L), envir = base::globalenv(), 
[17:28:17.187]                       inherits = FALSE)
[17:28:17.187]                     NULL
[17:28:17.187]                   }
[17:28:17.187]                   options(future.plan = NULL)
[17:28:17.187]                   if (is.na(NA_character_)) 
[17:28:17.187]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.187]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.187]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.187]                     .init = FALSE)
[17:28:17.187]                 }
[17:28:17.187]             }
[17:28:17.187]         }
[17:28:17.187]     })
[17:28:17.187]     if (TRUE) {
[17:28:17.187]         base::sink(type = "output", split = FALSE)
[17:28:17.187]         if (TRUE) {
[17:28:17.187]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.187]         }
[17:28:17.187]         else {
[17:28:17.187]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.187]         }
[17:28:17.187]         base::close(...future.stdout)
[17:28:17.187]         ...future.stdout <- NULL
[17:28:17.187]     }
[17:28:17.187]     ...future.result$conditions <- ...future.conditions
[17:28:17.187]     ...future.result$finished <- base::Sys.time()
[17:28:17.187]     ...future.result
[17:28:17.187] }
[17:28:17.191] assign_globals() ...
[17:28:17.191] List of 1
[17:28:17.191]  $ x: int [1:4] 0 1 2 3
[17:28:17.191]  - attr(*, "where")=List of 1
[17:28:17.191]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.191]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.191]  - attr(*, "resolved")= logi FALSE
[17:28:17.191]  - attr(*, "total_size")= num 64
[17:28:17.191]  - attr(*, "already-done")= logi TRUE
[17:28:17.194] - copied 'x' to environment
[17:28:17.194] assign_globals() ... done
[17:28:17.194] plan(): Setting new future strategy stack:
[17:28:17.195] List of future strategies:
[17:28:17.195] 1. sequential:
[17:28:17.195]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.195]    - tweaked: FALSE
[17:28:17.195]    - call: NULL
[17:28:17.195] plan(): nbrOfWorkers() = 1
[17:28:17.196] plan(): Setting new future strategy stack:
[17:28:17.196] List of future strategies:
[17:28:17.196] 1. sequential:
[17:28:17.196]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.196]    - tweaked: FALSE
[17:28:17.196]    - call: plan(strategy)
[17:28:17.197] plan(): nbrOfWorkers() = 1
[17:28:17.197] SequentialFuture started (and completed)
[17:28:17.198] - Launch lazy future ... done
[17:28:17.198] run() for 'SequentialFuture' ... done
[17:28:17.198] getGlobalsAndPackages() ...
[17:28:17.198] Searching for globals...
[17:28:17.199] - globals found: [3] '{', 'sample', 'x'
[17:28:17.199] Searching for globals ... DONE
[17:28:17.200] Resolving globals: FALSE
[17:28:17.200] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.200] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.201] - globals: [1] 'x'
[17:28:17.201] 
[17:28:17.201] getGlobalsAndPackages() ... DONE
[17:28:17.201] run() for 'Future' ...
[17:28:17.201] - state: 'created'
[17:28:17.202] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.202] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.202] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.202]   - Field: 'label'
[17:28:17.203]   - Field: 'local'
[17:28:17.203]   - Field: 'owner'
[17:28:17.203]   - Field: 'envir'
[17:28:17.203]   - Field: 'packages'
[17:28:17.203]   - Field: 'gc'
[17:28:17.203]   - Field: 'conditions'
[17:28:17.204]   - Field: 'expr'
[17:28:17.204]   - Field: 'uuid'
[17:28:17.204]   - Field: 'seed'
[17:28:17.204]   - Field: 'version'
[17:28:17.204]   - Field: 'result'
[17:28:17.204]   - Field: 'asynchronous'
[17:28:17.205]   - Field: 'calls'
[17:28:17.205]   - Field: 'globals'
[17:28:17.205]   - Field: 'stdout'
[17:28:17.205]   - Field: 'earlySignal'
[17:28:17.205]   - Field: 'lazy'
[17:28:17.205]   - Field: 'state'
[17:28:17.206] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.206] - Launch lazy future ...
[17:28:17.206] Packages needed by the future expression (n = 0): <none>
[17:28:17.206] Packages needed by future strategies (n = 0): <none>
[17:28:17.207] {
[17:28:17.207]     {
[17:28:17.207]         {
[17:28:17.207]             ...future.startTime <- base::Sys.time()
[17:28:17.207]             {
[17:28:17.207]                 {
[17:28:17.207]                   {
[17:28:17.207]                     {
[17:28:17.207]                       base::local({
[17:28:17.207]                         has_future <- base::requireNamespace("future", 
[17:28:17.207]                           quietly = TRUE)
[17:28:17.207]                         if (has_future) {
[17:28:17.207]                           ns <- base::getNamespace("future")
[17:28:17.207]                           version <- ns[[".package"]][["version"]]
[17:28:17.207]                           if (is.null(version)) 
[17:28:17.207]                             version <- utils::packageVersion("future")
[17:28:17.207]                         }
[17:28:17.207]                         else {
[17:28:17.207]                           version <- NULL
[17:28:17.207]                         }
[17:28:17.207]                         if (!has_future || version < "1.8.0") {
[17:28:17.207]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.207]                             "", base::R.version$version.string), 
[17:28:17.207]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:17.207]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.207]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.207]                               "release", "version")], collapse = " "), 
[17:28:17.207]                             hostname = base::Sys.info()[["nodename"]])
[17:28:17.207]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.207]                             info)
[17:28:17.207]                           info <- base::paste(info, collapse = "; ")
[17:28:17.207]                           if (!has_future) {
[17:28:17.207]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.207]                               info)
[17:28:17.207]                           }
[17:28:17.207]                           else {
[17:28:17.207]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.207]                               info, version)
[17:28:17.207]                           }
[17:28:17.207]                           base::stop(msg)
[17:28:17.207]                         }
[17:28:17.207]                       })
[17:28:17.207]                     }
[17:28:17.207]                     ...future.strategy.old <- future::plan("list")
[17:28:17.207]                     options(future.plan = NULL)
[17:28:17.207]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.207]                     future::plan("default", .cleanup = FALSE, 
[17:28:17.207]                       .init = FALSE)
[17:28:17.207]                   }
[17:28:17.207]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:28:17.207]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:28:17.207]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:28:17.207]                 }
[17:28:17.207]                 ...future.workdir <- getwd()
[17:28:17.207]             }
[17:28:17.207]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.207]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.207]         }
[17:28:17.207]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.207]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.207]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.207]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.207]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.207]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.207]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.207]             base::names(...future.oldOptions))
[17:28:17.207]     }
[17:28:17.207]     if (FALSE) {
[17:28:17.207]     }
[17:28:17.207]     else {
[17:28:17.207]         if (TRUE) {
[17:28:17.207]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.207]                 open = "w")
[17:28:17.207]         }
[17:28:17.207]         else {
[17:28:17.207]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.207]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.207]         }
[17:28:17.207]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.207]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.207]             base::sink(type = "output", split = FALSE)
[17:28:17.207]             base::close(...future.stdout)
[17:28:17.207]         }, add = TRUE)
[17:28:17.207]     }
[17:28:17.207]     ...future.frame <- base::sys.nframe()
[17:28:17.207]     ...future.conditions <- base::list()
[17:28:17.207]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.207]     if (FALSE) {
[17:28:17.207]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.207]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.207]     }
[17:28:17.207]     ...future.result <- base::tryCatch({
[17:28:17.207]         base::withCallingHandlers({
[17:28:17.207]             ...future.value <- base::withVisible(base::local({
[17:28:17.207]                 sample(x, size = 1L)
[17:28:17.207]             }))
[17:28:17.207]             future::FutureResult(value = ...future.value$value, 
[17:28:17.207]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.207]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.207]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.207]                     ...future.globalenv.names))
[17:28:17.207]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.207]         }, condition = base::local({
[17:28:17.207]             c <- base::c
[17:28:17.207]             inherits <- base::inherits
[17:28:17.207]             invokeRestart <- base::invokeRestart
[17:28:17.207]             length <- base::length
[17:28:17.207]             list <- base::list
[17:28:17.207]             seq.int <- base::seq.int
[17:28:17.207]             signalCondition <- base::signalCondition
[17:28:17.207]             sys.calls <- base::sys.calls
[17:28:17.207]             `[[` <- base::`[[`
[17:28:17.207]             `+` <- base::`+`
[17:28:17.207]             `<<-` <- base::`<<-`
[17:28:17.207]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.207]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.207]                   3L)]
[17:28:17.207]             }
[17:28:17.207]             function(cond) {
[17:28:17.207]                 is_error <- inherits(cond, "error")
[17:28:17.207]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.207]                   NULL)
[17:28:17.207]                 if (is_error) {
[17:28:17.207]                   sessionInformation <- function() {
[17:28:17.207]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.207]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.207]                       search = base::search(), system = base::Sys.info())
[17:28:17.207]                   }
[17:28:17.207]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.207]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.207]                     cond$call), session = sessionInformation(), 
[17:28:17.207]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.207]                   signalCondition(cond)
[17:28:17.207]                 }
[17:28:17.207]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.207]                 "immediateCondition"))) {
[17:28:17.207]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.207]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.207]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.207]                   if (TRUE && !signal) {
[17:28:17.207]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.207]                     {
[17:28:17.207]                       inherits <- base::inherits
[17:28:17.207]                       invokeRestart <- base::invokeRestart
[17:28:17.207]                       is.null <- base::is.null
[17:28:17.207]                       muffled <- FALSE
[17:28:17.207]                       if (inherits(cond, "message")) {
[17:28:17.207]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.207]                         if (muffled) 
[17:28:17.207]                           invokeRestart("muffleMessage")
[17:28:17.207]                       }
[17:28:17.207]                       else if (inherits(cond, "warning")) {
[17:28:17.207]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.207]                         if (muffled) 
[17:28:17.207]                           invokeRestart("muffleWarning")
[17:28:17.207]                       }
[17:28:17.207]                       else if (inherits(cond, "condition")) {
[17:28:17.207]                         if (!is.null(pattern)) {
[17:28:17.207]                           computeRestarts <- base::computeRestarts
[17:28:17.207]                           grepl <- base::grepl
[17:28:17.207]                           restarts <- computeRestarts(cond)
[17:28:17.207]                           for (restart in restarts) {
[17:28:17.207]                             name <- restart$name
[17:28:17.207]                             if (is.null(name)) 
[17:28:17.207]                               next
[17:28:17.207]                             if (!grepl(pattern, name)) 
[17:28:17.207]                               next
[17:28:17.207]                             invokeRestart(restart)
[17:28:17.207]                             muffled <- TRUE
[17:28:17.207]                             break
[17:28:17.207]                           }
[17:28:17.207]                         }
[17:28:17.207]                       }
[17:28:17.207]                       invisible(muffled)
[17:28:17.207]                     }
[17:28:17.207]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.207]                   }
[17:28:17.207]                 }
[17:28:17.207]                 else {
[17:28:17.207]                   if (TRUE) {
[17:28:17.207]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.207]                     {
[17:28:17.207]                       inherits <- base::inherits
[17:28:17.207]                       invokeRestart <- base::invokeRestart
[17:28:17.207]                       is.null <- base::is.null
[17:28:17.207]                       muffled <- FALSE
[17:28:17.207]                       if (inherits(cond, "message")) {
[17:28:17.207]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.207]                         if (muffled) 
[17:28:17.207]                           invokeRestart("muffleMessage")
[17:28:17.207]                       }
[17:28:17.207]                       else if (inherits(cond, "warning")) {
[17:28:17.207]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.207]                         if (muffled) 
[17:28:17.207]                           invokeRestart("muffleWarning")
[17:28:17.207]                       }
[17:28:17.207]                       else if (inherits(cond, "condition")) {
[17:28:17.207]                         if (!is.null(pattern)) {
[17:28:17.207]                           computeRestarts <- base::computeRestarts
[17:28:17.207]                           grepl <- base::grepl
[17:28:17.207]                           restarts <- computeRestarts(cond)
[17:28:17.207]                           for (restart in restarts) {
[17:28:17.207]                             name <- restart$name
[17:28:17.207]                             if (is.null(name)) 
[17:28:17.207]                               next
[17:28:17.207]                             if (!grepl(pattern, name)) 
[17:28:17.207]                               next
[17:28:17.207]                             invokeRestart(restart)
[17:28:17.207]                             muffled <- TRUE
[17:28:17.207]                             break
[17:28:17.207]                           }
[17:28:17.207]                         }
[17:28:17.207]                       }
[17:28:17.207]                       invisible(muffled)
[17:28:17.207]                     }
[17:28:17.207]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.207]                   }
[17:28:17.207]                 }
[17:28:17.207]             }
[17:28:17.207]         }))
[17:28:17.207]     }, error = function(ex) {
[17:28:17.207]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.207]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.207]                 ...future.rng), started = ...future.startTime, 
[17:28:17.207]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.207]             version = "1.8"), class = "FutureResult")
[17:28:17.207]     }, finally = {
[17:28:17.207]         if (!identical(...future.workdir, getwd())) 
[17:28:17.207]             setwd(...future.workdir)
[17:28:17.207]         {
[17:28:17.207]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.207]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.207]             }
[17:28:17.207]             base::options(...future.oldOptions)
[17:28:17.207]             if (.Platform$OS.type == "windows") {
[17:28:17.207]                 old_names <- names(...future.oldEnvVars)
[17:28:17.207]                 envs <- base::Sys.getenv()
[17:28:17.207]                 names <- names(envs)
[17:28:17.207]                 common <- intersect(names, old_names)
[17:28:17.207]                 added <- setdiff(names, old_names)
[17:28:17.207]                 removed <- setdiff(old_names, names)
[17:28:17.207]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.207]                   envs[common]]
[17:28:17.207]                 NAMES <- toupper(changed)
[17:28:17.207]                 args <- list()
[17:28:17.207]                 for (kk in seq_along(NAMES)) {
[17:28:17.207]                   name <- changed[[kk]]
[17:28:17.207]                   NAME <- NAMES[[kk]]
[17:28:17.207]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.207]                     next
[17:28:17.207]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.207]                 }
[17:28:17.207]                 NAMES <- toupper(added)
[17:28:17.207]                 for (kk in seq_along(NAMES)) {
[17:28:17.207]                   name <- added[[kk]]
[17:28:17.207]                   NAME <- NAMES[[kk]]
[17:28:17.207]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.207]                     next
[17:28:17.207]                   args[[name]] <- ""
[17:28:17.207]                 }
[17:28:17.207]                 NAMES <- toupper(removed)
[17:28:17.207]                 for (kk in seq_along(NAMES)) {
[17:28:17.207]                   name <- removed[[kk]]
[17:28:17.207]                   NAME <- NAMES[[kk]]
[17:28:17.207]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.207]                     next
[17:28:17.207]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.207]                 }
[17:28:17.207]                 if (length(args) > 0) 
[17:28:17.207]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.207]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.207]             }
[17:28:17.207]             else {
[17:28:17.207]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.207]             }
[17:28:17.207]             {
[17:28:17.207]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.207]                   0L) {
[17:28:17.207]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.207]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.207]                   base::options(opts)
[17:28:17.207]                 }
[17:28:17.207]                 {
[17:28:17.207]                   {
[17:28:17.207]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:17.207]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:17.207]                     -1344458670L), envir = base::globalenv(), 
[17:28:17.207]                       inherits = FALSE)
[17:28:17.207]                     NULL
[17:28:17.207]                   }
[17:28:17.207]                   options(future.plan = NULL)
[17:28:17.207]                   if (is.na(NA_character_)) 
[17:28:17.207]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.207]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.207]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.207]                     .init = FALSE)
[17:28:17.207]                 }
[17:28:17.207]             }
[17:28:17.207]         }
[17:28:17.207]     })
[17:28:17.207]     if (TRUE) {
[17:28:17.207]         base::sink(type = "output", split = FALSE)
[17:28:17.207]         if (TRUE) {
[17:28:17.207]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.207]         }
[17:28:17.207]         else {
[17:28:17.207]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.207]         }
[17:28:17.207]         base::close(...future.stdout)
[17:28:17.207]         ...future.stdout <- NULL
[17:28:17.207]     }
[17:28:17.207]     ...future.result$conditions <- ...future.conditions
[17:28:17.207]     ...future.result$finished <- base::Sys.time()
[17:28:17.207]     ...future.result
[17:28:17.207] }
[17:28:17.211] assign_globals() ...
[17:28:17.211] List of 1
[17:28:17.211]  $ x: int [1:4] 0 1 2 3
[17:28:17.211]  - attr(*, "where")=List of 1
[17:28:17.211]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.211]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.211]  - attr(*, "resolved")= logi FALSE
[17:28:17.211]  - attr(*, "total_size")= num 64
[17:28:17.211]  - attr(*, "already-done")= logi TRUE
[17:28:17.215] - copied 'x' to environment
[17:28:17.215] assign_globals() ... done
[17:28:17.215] plan(): Setting new future strategy stack:
[17:28:17.215] List of future strategies:
[17:28:17.215] 1. sequential:
[17:28:17.215]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.215]    - tweaked: FALSE
[17:28:17.215]    - call: NULL
[17:28:17.216] plan(): nbrOfWorkers() = 1
[17:28:17.217] plan(): Setting new future strategy stack:
[17:28:17.217] List of future strategies:
[17:28:17.217] 1. sequential:
[17:28:17.217]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.217]    - tweaked: FALSE
[17:28:17.217]    - call: plan(strategy)
[17:28:17.218] plan(): nbrOfWorkers() = 1
[17:28:17.218] SequentialFuture started (and completed)
[17:28:17.218] - Launch lazy future ... done
[17:28:17.218] run() for 'SequentialFuture' ... done
[17:28:17.219] resolve() on list ...
[17:28:17.219]  recursive: 0
[17:28:17.219]  length: 4
[17:28:17.219] 
[17:28:17.219] resolved() for 'SequentialFuture' ...
[17:28:17.219] - state: 'finished'
[17:28:17.220] - run: TRUE
[17:28:17.220] - result: 'FutureResult'
[17:28:17.220] resolved() for 'SequentialFuture' ... done
[17:28:17.220] Future #1
[17:28:17.220] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:28:17.221] - nx: 4
[17:28:17.221] - relay: TRUE
[17:28:17.221] - stdout: TRUE
[17:28:17.221] - signal: TRUE
[17:28:17.221] - resignal: FALSE
[17:28:17.221] - force: TRUE
[17:28:17.221] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.222] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.222]  - until=1
[17:28:17.222]  - relaying element #1
[17:28:17.222] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.222] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.222] signalConditionsASAP(SequentialFuture, pos=1) ... done
[17:28:17.223]  length: 3 (resolved future 1)
[17:28:17.223] resolved() for 'SequentialFuture' ...
[17:28:17.223] - state: 'finished'
[17:28:17.223] - run: TRUE
[17:28:17.223] - result: 'FutureResult'
[17:28:17.224] resolved() for 'SequentialFuture' ... done
[17:28:17.224] Future #2
[17:28:17.224] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:28:17.224] - nx: 4
[17:28:17.224] - relay: TRUE
[17:28:17.224] - stdout: TRUE
[17:28:17.225] - signal: TRUE
[17:28:17.225] - resignal: FALSE
[17:28:17.225] - force: TRUE
[17:28:17.225] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.225] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.225]  - until=2
[17:28:17.225]  - relaying element #2
[17:28:17.226] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.226] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.226] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:28:17.226]  length: 2 (resolved future 2)
[17:28:17.226] resolved() for 'SequentialFuture' ...
[17:28:17.227] - state: 'finished'
[17:28:17.227] - run: TRUE
[17:28:17.227] - result: 'FutureResult'
[17:28:17.227] resolved() for 'SequentialFuture' ... done
[17:28:17.227] Future #3
[17:28:17.228] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:28:17.228] - nx: 4
[17:28:17.228] - relay: TRUE
[17:28:17.228] - stdout: TRUE
[17:28:17.228] - signal: TRUE
[17:28:17.228] - resignal: FALSE
[17:28:17.228] - force: TRUE
[17:28:17.229] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.229] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.229]  - until=3
[17:28:17.229]  - relaying element #3
[17:28:17.229] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.229] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.230] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:28:17.230]  length: 1 (resolved future 3)
[17:28:17.230] resolved() for 'SequentialFuture' ...
[17:28:17.230] - state: 'finished'
[17:28:17.230] - run: TRUE
[17:28:17.231] - result: 'FutureResult'
[17:28:17.231] resolved() for 'SequentialFuture' ... done
[17:28:17.231] Future #4
[17:28:17.231] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:28:17.231] - nx: 4
[17:28:17.231] - relay: TRUE
[17:28:17.232] - stdout: TRUE
[17:28:17.232] - signal: TRUE
[17:28:17.232] - resignal: FALSE
[17:28:17.232] - force: TRUE
[17:28:17.232] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.232] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.232]  - until=4
[17:28:17.233]  - relaying element #4
[17:28:17.233] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.233] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.233] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:28:17.233]  length: 0 (resolved future 4)
[17:28:17.234] Relaying remaining futures
[17:28:17.234] signalConditionsASAP(NULL, pos=0) ...
[17:28:17.234] - nx: 4
[17:28:17.234] - relay: TRUE
[17:28:17.234] - stdout: TRUE
[17:28:17.234] - signal: TRUE
[17:28:17.234] - resignal: FALSE
[17:28:17.235] - force: TRUE
[17:28:17.235] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.235] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:28:17.235] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.235] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.235] signalConditionsASAP(NULL, pos=0) ... done
[17:28:17.236] resolve() on list ... DONE
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[17:28:17.236] getGlobalsAndPackages() ...
[17:28:17.236] Searching for globals...
[17:28:17.237] - globals found: [3] '{', 'sample', 'x'
[17:28:17.238] Searching for globals ... DONE
[17:28:17.238] Resolving globals: FALSE
[17:28:17.238] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.239] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.239] - globals: [1] 'x'
[17:28:17.239] 
[17:28:17.239] getGlobalsAndPackages() ... DONE
[17:28:17.239] run() for 'Future' ...
[17:28:17.240] - state: 'created'
[17:28:17.240] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.240] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.240] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.241]   - Field: 'label'
[17:28:17.241]   - Field: 'local'
[17:28:17.241]   - Field: 'owner'
[17:28:17.241]   - Field: 'envir'
[17:28:17.241]   - Field: 'packages'
[17:28:17.241]   - Field: 'gc'
[17:28:17.242]   - Field: 'conditions'
[17:28:17.242]   - Field: 'expr'
[17:28:17.242]   - Field: 'uuid'
[17:28:17.242]   - Field: 'seed'
[17:28:17.242]   - Field: 'version'
[17:28:17.242]   - Field: 'result'
[17:28:17.243]   - Field: 'asynchronous'
[17:28:17.243]   - Field: 'calls'
[17:28:17.243]   - Field: 'globals'
[17:28:17.243]   - Field: 'stdout'
[17:28:17.243]   - Field: 'earlySignal'
[17:28:17.244]   - Field: 'lazy'
[17:28:17.244]   - Field: 'state'
[17:28:17.244] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.244] - Launch lazy future ...
[17:28:17.244] Packages needed by the future expression (n = 0): <none>
[17:28:17.245] Packages needed by future strategies (n = 0): <none>
[17:28:17.246] {
[17:28:17.246]     {
[17:28:17.246]         {
[17:28:17.246]             ...future.startTime <- base::Sys.time()
[17:28:17.246]             {
[17:28:17.246]                 {
[17:28:17.246]                   {
[17:28:17.246]                     {
[17:28:17.246]                       base::local({
[17:28:17.246]                         has_future <- base::requireNamespace("future", 
[17:28:17.246]                           quietly = TRUE)
[17:28:17.246]                         if (has_future) {
[17:28:17.246]                           ns <- base::getNamespace("future")
[17:28:17.246]                           version <- ns[[".package"]][["version"]]
[17:28:17.246]                           if (is.null(version)) 
[17:28:17.246]                             version <- utils::packageVersion("future")
[17:28:17.246]                         }
[17:28:17.246]                         else {
[17:28:17.246]                           version <- NULL
[17:28:17.246]                         }
[17:28:17.246]                         if (!has_future || version < "1.8.0") {
[17:28:17.246]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.246]                             "", base::R.version$version.string), 
[17:28:17.246]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:17.246]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.246]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.246]                               "release", "version")], collapse = " "), 
[17:28:17.246]                             hostname = base::Sys.info()[["nodename"]])
[17:28:17.246]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.246]                             info)
[17:28:17.246]                           info <- base::paste(info, collapse = "; ")
[17:28:17.246]                           if (!has_future) {
[17:28:17.246]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.246]                               info)
[17:28:17.246]                           }
[17:28:17.246]                           else {
[17:28:17.246]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.246]                               info, version)
[17:28:17.246]                           }
[17:28:17.246]                           base::stop(msg)
[17:28:17.246]                         }
[17:28:17.246]                       })
[17:28:17.246]                     }
[17:28:17.246]                     ...future.strategy.old <- future::plan("list")
[17:28:17.246]                     options(future.plan = NULL)
[17:28:17.246]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.246]                     future::plan("default", .cleanup = FALSE, 
[17:28:17.246]                       .init = FALSE)
[17:28:17.246]                   }
[17:28:17.246]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:28:17.246]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:28:17.246]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:28:17.246]                 }
[17:28:17.246]                 ...future.workdir <- getwd()
[17:28:17.246]             }
[17:28:17.246]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.246]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.246]         }
[17:28:17.246]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.246]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.246]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.246]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.246]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.246]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.246]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.246]             base::names(...future.oldOptions))
[17:28:17.246]     }
[17:28:17.246]     if (FALSE) {
[17:28:17.246]     }
[17:28:17.246]     else {
[17:28:17.246]         if (TRUE) {
[17:28:17.246]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.246]                 open = "w")
[17:28:17.246]         }
[17:28:17.246]         else {
[17:28:17.246]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.246]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.246]         }
[17:28:17.246]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.246]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.246]             base::sink(type = "output", split = FALSE)
[17:28:17.246]             base::close(...future.stdout)
[17:28:17.246]         }, add = TRUE)
[17:28:17.246]     }
[17:28:17.246]     ...future.frame <- base::sys.nframe()
[17:28:17.246]     ...future.conditions <- base::list()
[17:28:17.246]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.246]     if (FALSE) {
[17:28:17.246]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.246]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.246]     }
[17:28:17.246]     ...future.result <- base::tryCatch({
[17:28:17.246]         base::withCallingHandlers({
[17:28:17.246]             ...future.value <- base::withVisible(base::local({
[17:28:17.246]                 sample(x, size = 1L)
[17:28:17.246]             }))
[17:28:17.246]             future::FutureResult(value = ...future.value$value, 
[17:28:17.246]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.246]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.246]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.246]                     ...future.globalenv.names))
[17:28:17.246]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.246]         }, condition = base::local({
[17:28:17.246]             c <- base::c
[17:28:17.246]             inherits <- base::inherits
[17:28:17.246]             invokeRestart <- base::invokeRestart
[17:28:17.246]             length <- base::length
[17:28:17.246]             list <- base::list
[17:28:17.246]             seq.int <- base::seq.int
[17:28:17.246]             signalCondition <- base::signalCondition
[17:28:17.246]             sys.calls <- base::sys.calls
[17:28:17.246]             `[[` <- base::`[[`
[17:28:17.246]             `+` <- base::`+`
[17:28:17.246]             `<<-` <- base::`<<-`
[17:28:17.246]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.246]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.246]                   3L)]
[17:28:17.246]             }
[17:28:17.246]             function(cond) {
[17:28:17.246]                 is_error <- inherits(cond, "error")
[17:28:17.246]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.246]                   NULL)
[17:28:17.246]                 if (is_error) {
[17:28:17.246]                   sessionInformation <- function() {
[17:28:17.246]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.246]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.246]                       search = base::search(), system = base::Sys.info())
[17:28:17.246]                   }
[17:28:17.246]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.246]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.246]                     cond$call), session = sessionInformation(), 
[17:28:17.246]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.246]                   signalCondition(cond)
[17:28:17.246]                 }
[17:28:17.246]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.246]                 "immediateCondition"))) {
[17:28:17.246]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.246]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.246]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.246]                   if (TRUE && !signal) {
[17:28:17.246]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.246]                     {
[17:28:17.246]                       inherits <- base::inherits
[17:28:17.246]                       invokeRestart <- base::invokeRestart
[17:28:17.246]                       is.null <- base::is.null
[17:28:17.246]                       muffled <- FALSE
[17:28:17.246]                       if (inherits(cond, "message")) {
[17:28:17.246]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.246]                         if (muffled) 
[17:28:17.246]                           invokeRestart("muffleMessage")
[17:28:17.246]                       }
[17:28:17.246]                       else if (inherits(cond, "warning")) {
[17:28:17.246]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.246]                         if (muffled) 
[17:28:17.246]                           invokeRestart("muffleWarning")
[17:28:17.246]                       }
[17:28:17.246]                       else if (inherits(cond, "condition")) {
[17:28:17.246]                         if (!is.null(pattern)) {
[17:28:17.246]                           computeRestarts <- base::computeRestarts
[17:28:17.246]                           grepl <- base::grepl
[17:28:17.246]                           restarts <- computeRestarts(cond)
[17:28:17.246]                           for (restart in restarts) {
[17:28:17.246]                             name <- restart$name
[17:28:17.246]                             if (is.null(name)) 
[17:28:17.246]                               next
[17:28:17.246]                             if (!grepl(pattern, name)) 
[17:28:17.246]                               next
[17:28:17.246]                             invokeRestart(restart)
[17:28:17.246]                             muffled <- TRUE
[17:28:17.246]                             break
[17:28:17.246]                           }
[17:28:17.246]                         }
[17:28:17.246]                       }
[17:28:17.246]                       invisible(muffled)
[17:28:17.246]                     }
[17:28:17.246]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.246]                   }
[17:28:17.246]                 }
[17:28:17.246]                 else {
[17:28:17.246]                   if (TRUE) {
[17:28:17.246]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.246]                     {
[17:28:17.246]                       inherits <- base::inherits
[17:28:17.246]                       invokeRestart <- base::invokeRestart
[17:28:17.246]                       is.null <- base::is.null
[17:28:17.246]                       muffled <- FALSE
[17:28:17.246]                       if (inherits(cond, "message")) {
[17:28:17.246]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.246]                         if (muffled) 
[17:28:17.246]                           invokeRestart("muffleMessage")
[17:28:17.246]                       }
[17:28:17.246]                       else if (inherits(cond, "warning")) {
[17:28:17.246]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.246]                         if (muffled) 
[17:28:17.246]                           invokeRestart("muffleWarning")
[17:28:17.246]                       }
[17:28:17.246]                       else if (inherits(cond, "condition")) {
[17:28:17.246]                         if (!is.null(pattern)) {
[17:28:17.246]                           computeRestarts <- base::computeRestarts
[17:28:17.246]                           grepl <- base::grepl
[17:28:17.246]                           restarts <- computeRestarts(cond)
[17:28:17.246]                           for (restart in restarts) {
[17:28:17.246]                             name <- restart$name
[17:28:17.246]                             if (is.null(name)) 
[17:28:17.246]                               next
[17:28:17.246]                             if (!grepl(pattern, name)) 
[17:28:17.246]                               next
[17:28:17.246]                             invokeRestart(restart)
[17:28:17.246]                             muffled <- TRUE
[17:28:17.246]                             break
[17:28:17.246]                           }
[17:28:17.246]                         }
[17:28:17.246]                       }
[17:28:17.246]                       invisible(muffled)
[17:28:17.246]                     }
[17:28:17.246]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.246]                   }
[17:28:17.246]                 }
[17:28:17.246]             }
[17:28:17.246]         }))
[17:28:17.246]     }, error = function(ex) {
[17:28:17.246]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.246]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.246]                 ...future.rng), started = ...future.startTime, 
[17:28:17.246]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.246]             version = "1.8"), class = "FutureResult")
[17:28:17.246]     }, finally = {
[17:28:17.246]         if (!identical(...future.workdir, getwd())) 
[17:28:17.246]             setwd(...future.workdir)
[17:28:17.246]         {
[17:28:17.246]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.246]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.246]             }
[17:28:17.246]             base::options(...future.oldOptions)
[17:28:17.246]             if (.Platform$OS.type == "windows") {
[17:28:17.246]                 old_names <- names(...future.oldEnvVars)
[17:28:17.246]                 envs <- base::Sys.getenv()
[17:28:17.246]                 names <- names(envs)
[17:28:17.246]                 common <- intersect(names, old_names)
[17:28:17.246]                 added <- setdiff(names, old_names)
[17:28:17.246]                 removed <- setdiff(old_names, names)
[17:28:17.246]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.246]                   envs[common]]
[17:28:17.246]                 NAMES <- toupper(changed)
[17:28:17.246]                 args <- list()
[17:28:17.246]                 for (kk in seq_along(NAMES)) {
[17:28:17.246]                   name <- changed[[kk]]
[17:28:17.246]                   NAME <- NAMES[[kk]]
[17:28:17.246]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.246]                     next
[17:28:17.246]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.246]                 }
[17:28:17.246]                 NAMES <- toupper(added)
[17:28:17.246]                 for (kk in seq_along(NAMES)) {
[17:28:17.246]                   name <- added[[kk]]
[17:28:17.246]                   NAME <- NAMES[[kk]]
[17:28:17.246]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.246]                     next
[17:28:17.246]                   args[[name]] <- ""
[17:28:17.246]                 }
[17:28:17.246]                 NAMES <- toupper(removed)
[17:28:17.246]                 for (kk in seq_along(NAMES)) {
[17:28:17.246]                   name <- removed[[kk]]
[17:28:17.246]                   NAME <- NAMES[[kk]]
[17:28:17.246]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.246]                     next
[17:28:17.246]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.246]                 }
[17:28:17.246]                 if (length(args) > 0) 
[17:28:17.246]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.246]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.246]             }
[17:28:17.246]             else {
[17:28:17.246]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.246]             }
[17:28:17.246]             {
[17:28:17.246]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.246]                   0L) {
[17:28:17.246]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.246]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.246]                   base::options(opts)
[17:28:17.246]                 }
[17:28:17.246]                 {
[17:28:17.246]                   {
[17:28:17.246]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:17.246]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:17.246]                     -1344458670L), envir = base::globalenv(), 
[17:28:17.246]                       inherits = FALSE)
[17:28:17.246]                     NULL
[17:28:17.246]                   }
[17:28:17.246]                   options(future.plan = NULL)
[17:28:17.246]                   if (is.na(NA_character_)) 
[17:28:17.246]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.246]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.246]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.246]                     .init = FALSE)
[17:28:17.246]                 }
[17:28:17.246]             }
[17:28:17.246]         }
[17:28:17.246]     })
[17:28:17.246]     if (TRUE) {
[17:28:17.246]         base::sink(type = "output", split = FALSE)
[17:28:17.246]         if (TRUE) {
[17:28:17.246]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.246]         }
[17:28:17.246]         else {
[17:28:17.246]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.246]         }
[17:28:17.246]         base::close(...future.stdout)
[17:28:17.246]         ...future.stdout <- NULL
[17:28:17.246]     }
[17:28:17.246]     ...future.result$conditions <- ...future.conditions
[17:28:17.246]     ...future.result$finished <- base::Sys.time()
[17:28:17.246]     ...future.result
[17:28:17.246] }
[17:28:17.250] assign_globals() ...
[17:28:17.250] List of 1
[17:28:17.250]  $ x: int [1:4] 0 1 2 3
[17:28:17.250]  - attr(*, "where")=List of 1
[17:28:17.250]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.250]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.250]  - attr(*, "resolved")= logi FALSE
[17:28:17.250]  - attr(*, "total_size")= num 64
[17:28:17.250]  - attr(*, "already-done")= logi TRUE
[17:28:17.253] - copied 'x' to environment
[17:28:17.253] assign_globals() ... done
[17:28:17.253] plan(): Setting new future strategy stack:
[17:28:17.253] List of future strategies:
[17:28:17.253] 1. sequential:
[17:28:17.253]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.253]    - tweaked: FALSE
[17:28:17.253]    - call: NULL
[17:28:17.254] plan(): nbrOfWorkers() = 1
[17:28:17.255] plan(): Setting new future strategy stack:
[17:28:17.255] List of future strategies:
[17:28:17.255] 1. sequential:
[17:28:17.255]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.255]    - tweaked: FALSE
[17:28:17.255]    - call: plan(strategy)
[17:28:17.256] plan(): nbrOfWorkers() = 1
[17:28:17.256] SequentialFuture started (and completed)
[17:28:17.256] - Launch lazy future ... done
[17:28:17.256] run() for 'SequentialFuture' ... done
[17:28:17.257] getGlobalsAndPackages() ...
[17:28:17.257] Searching for globals...
[17:28:17.258] - globals found: [3] '{', 'sample', 'x'
[17:28:17.258] Searching for globals ... DONE
[17:28:17.258] Resolving globals: FALSE
[17:28:17.259] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.259] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.259] - globals: [1] 'x'
[17:28:17.260] 
[17:28:17.260] getGlobalsAndPackages() ... DONE
[17:28:17.260] run() for 'Future' ...
[17:28:17.260] - state: 'created'
[17:28:17.260] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.261] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.261] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.261]   - Field: 'label'
[17:28:17.261]   - Field: 'local'
[17:28:17.261]   - Field: 'owner'
[17:28:17.262]   - Field: 'envir'
[17:28:17.262]   - Field: 'packages'
[17:28:17.262]   - Field: 'gc'
[17:28:17.262]   - Field: 'conditions'
[17:28:17.262]   - Field: 'expr'
[17:28:17.262]   - Field: 'uuid'
[17:28:17.263]   - Field: 'seed'
[17:28:17.263]   - Field: 'version'
[17:28:17.263]   - Field: 'result'
[17:28:17.263]   - Field: 'asynchronous'
[17:28:17.263]   - Field: 'calls'
[17:28:17.264]   - Field: 'globals'
[17:28:17.264]   - Field: 'stdout'
[17:28:17.264]   - Field: 'earlySignal'
[17:28:17.264]   - Field: 'lazy'
[17:28:17.264]   - Field: 'state'
[17:28:17.264] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.265] - Launch lazy future ...
[17:28:17.265] Packages needed by the future expression (n = 0): <none>
[17:28:17.265] Packages needed by future strategies (n = 0): <none>
[17:28:17.265] {
[17:28:17.265]     {
[17:28:17.265]         {
[17:28:17.265]             ...future.startTime <- base::Sys.time()
[17:28:17.265]             {
[17:28:17.265]                 {
[17:28:17.265]                   {
[17:28:17.265]                     {
[17:28:17.265]                       base::local({
[17:28:17.265]                         has_future <- base::requireNamespace("future", 
[17:28:17.265]                           quietly = TRUE)
[17:28:17.265]                         if (has_future) {
[17:28:17.265]                           ns <- base::getNamespace("future")
[17:28:17.265]                           version <- ns[[".package"]][["version"]]
[17:28:17.265]                           if (is.null(version)) 
[17:28:17.265]                             version <- utils::packageVersion("future")
[17:28:17.265]                         }
[17:28:17.265]                         else {
[17:28:17.265]                           version <- NULL
[17:28:17.265]                         }
[17:28:17.265]                         if (!has_future || version < "1.8.0") {
[17:28:17.265]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.265]                             "", base::R.version$version.string), 
[17:28:17.265]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:17.265]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.265]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.265]                               "release", "version")], collapse = " "), 
[17:28:17.265]                             hostname = base::Sys.info()[["nodename"]])
[17:28:17.265]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.265]                             info)
[17:28:17.265]                           info <- base::paste(info, collapse = "; ")
[17:28:17.265]                           if (!has_future) {
[17:28:17.265]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.265]                               info)
[17:28:17.265]                           }
[17:28:17.265]                           else {
[17:28:17.265]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.265]                               info, version)
[17:28:17.265]                           }
[17:28:17.265]                           base::stop(msg)
[17:28:17.265]                         }
[17:28:17.265]                       })
[17:28:17.265]                     }
[17:28:17.265]                     ...future.strategy.old <- future::plan("list")
[17:28:17.265]                     options(future.plan = NULL)
[17:28:17.265]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.265]                     future::plan("default", .cleanup = FALSE, 
[17:28:17.265]                       .init = FALSE)
[17:28:17.265]                   }
[17:28:17.265]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:28:17.265]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:28:17.265]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:28:17.265]                 }
[17:28:17.265]                 ...future.workdir <- getwd()
[17:28:17.265]             }
[17:28:17.265]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.265]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.265]         }
[17:28:17.265]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.265]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.265]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.265]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.265]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.265]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.265]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.265]             base::names(...future.oldOptions))
[17:28:17.265]     }
[17:28:17.265]     if (FALSE) {
[17:28:17.265]     }
[17:28:17.265]     else {
[17:28:17.265]         if (TRUE) {
[17:28:17.265]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.265]                 open = "w")
[17:28:17.265]         }
[17:28:17.265]         else {
[17:28:17.265]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.265]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.265]         }
[17:28:17.265]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.265]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.265]             base::sink(type = "output", split = FALSE)
[17:28:17.265]             base::close(...future.stdout)
[17:28:17.265]         }, add = TRUE)
[17:28:17.265]     }
[17:28:17.265]     ...future.frame <- base::sys.nframe()
[17:28:17.265]     ...future.conditions <- base::list()
[17:28:17.265]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.265]     if (FALSE) {
[17:28:17.265]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.265]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.265]     }
[17:28:17.265]     ...future.result <- base::tryCatch({
[17:28:17.265]         base::withCallingHandlers({
[17:28:17.265]             ...future.value <- base::withVisible(base::local({
[17:28:17.265]                 sample(x, size = 1L)
[17:28:17.265]             }))
[17:28:17.265]             future::FutureResult(value = ...future.value$value, 
[17:28:17.265]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.265]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.265]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.265]                     ...future.globalenv.names))
[17:28:17.265]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.265]         }, condition = base::local({
[17:28:17.265]             c <- base::c
[17:28:17.265]             inherits <- base::inherits
[17:28:17.265]             invokeRestart <- base::invokeRestart
[17:28:17.265]             length <- base::length
[17:28:17.265]             list <- base::list
[17:28:17.265]             seq.int <- base::seq.int
[17:28:17.265]             signalCondition <- base::signalCondition
[17:28:17.265]             sys.calls <- base::sys.calls
[17:28:17.265]             `[[` <- base::`[[`
[17:28:17.265]             `+` <- base::`+`
[17:28:17.265]             `<<-` <- base::`<<-`
[17:28:17.265]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.265]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.265]                   3L)]
[17:28:17.265]             }
[17:28:17.265]             function(cond) {
[17:28:17.265]                 is_error <- inherits(cond, "error")
[17:28:17.265]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.265]                   NULL)
[17:28:17.265]                 if (is_error) {
[17:28:17.265]                   sessionInformation <- function() {
[17:28:17.265]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.265]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.265]                       search = base::search(), system = base::Sys.info())
[17:28:17.265]                   }
[17:28:17.265]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.265]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.265]                     cond$call), session = sessionInformation(), 
[17:28:17.265]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.265]                   signalCondition(cond)
[17:28:17.265]                 }
[17:28:17.265]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.265]                 "immediateCondition"))) {
[17:28:17.265]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.265]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.265]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.265]                   if (TRUE && !signal) {
[17:28:17.265]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.265]                     {
[17:28:17.265]                       inherits <- base::inherits
[17:28:17.265]                       invokeRestart <- base::invokeRestart
[17:28:17.265]                       is.null <- base::is.null
[17:28:17.265]                       muffled <- FALSE
[17:28:17.265]                       if (inherits(cond, "message")) {
[17:28:17.265]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.265]                         if (muffled) 
[17:28:17.265]                           invokeRestart("muffleMessage")
[17:28:17.265]                       }
[17:28:17.265]                       else if (inherits(cond, "warning")) {
[17:28:17.265]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.265]                         if (muffled) 
[17:28:17.265]                           invokeRestart("muffleWarning")
[17:28:17.265]                       }
[17:28:17.265]                       else if (inherits(cond, "condition")) {
[17:28:17.265]                         if (!is.null(pattern)) {
[17:28:17.265]                           computeRestarts <- base::computeRestarts
[17:28:17.265]                           grepl <- base::grepl
[17:28:17.265]                           restarts <- computeRestarts(cond)
[17:28:17.265]                           for (restart in restarts) {
[17:28:17.265]                             name <- restart$name
[17:28:17.265]                             if (is.null(name)) 
[17:28:17.265]                               next
[17:28:17.265]                             if (!grepl(pattern, name)) 
[17:28:17.265]                               next
[17:28:17.265]                             invokeRestart(restart)
[17:28:17.265]                             muffled <- TRUE
[17:28:17.265]                             break
[17:28:17.265]                           }
[17:28:17.265]                         }
[17:28:17.265]                       }
[17:28:17.265]                       invisible(muffled)
[17:28:17.265]                     }
[17:28:17.265]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.265]                   }
[17:28:17.265]                 }
[17:28:17.265]                 else {
[17:28:17.265]                   if (TRUE) {
[17:28:17.265]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.265]                     {
[17:28:17.265]                       inherits <- base::inherits
[17:28:17.265]                       invokeRestart <- base::invokeRestart
[17:28:17.265]                       is.null <- base::is.null
[17:28:17.265]                       muffled <- FALSE
[17:28:17.265]                       if (inherits(cond, "message")) {
[17:28:17.265]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.265]                         if (muffled) 
[17:28:17.265]                           invokeRestart("muffleMessage")
[17:28:17.265]                       }
[17:28:17.265]                       else if (inherits(cond, "warning")) {
[17:28:17.265]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.265]                         if (muffled) 
[17:28:17.265]                           invokeRestart("muffleWarning")
[17:28:17.265]                       }
[17:28:17.265]                       else if (inherits(cond, "condition")) {
[17:28:17.265]                         if (!is.null(pattern)) {
[17:28:17.265]                           computeRestarts <- base::computeRestarts
[17:28:17.265]                           grepl <- base::grepl
[17:28:17.265]                           restarts <- computeRestarts(cond)
[17:28:17.265]                           for (restart in restarts) {
[17:28:17.265]                             name <- restart$name
[17:28:17.265]                             if (is.null(name)) 
[17:28:17.265]                               next
[17:28:17.265]                             if (!grepl(pattern, name)) 
[17:28:17.265]                               next
[17:28:17.265]                             invokeRestart(restart)
[17:28:17.265]                             muffled <- TRUE
[17:28:17.265]                             break
[17:28:17.265]                           }
[17:28:17.265]                         }
[17:28:17.265]                       }
[17:28:17.265]                       invisible(muffled)
[17:28:17.265]                     }
[17:28:17.265]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.265]                   }
[17:28:17.265]                 }
[17:28:17.265]             }
[17:28:17.265]         }))
[17:28:17.265]     }, error = function(ex) {
[17:28:17.265]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.265]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.265]                 ...future.rng), started = ...future.startTime, 
[17:28:17.265]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.265]             version = "1.8"), class = "FutureResult")
[17:28:17.265]     }, finally = {
[17:28:17.265]         if (!identical(...future.workdir, getwd())) 
[17:28:17.265]             setwd(...future.workdir)
[17:28:17.265]         {
[17:28:17.265]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.265]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.265]             }
[17:28:17.265]             base::options(...future.oldOptions)
[17:28:17.265]             if (.Platform$OS.type == "windows") {
[17:28:17.265]                 old_names <- names(...future.oldEnvVars)
[17:28:17.265]                 envs <- base::Sys.getenv()
[17:28:17.265]                 names <- names(envs)
[17:28:17.265]                 common <- intersect(names, old_names)
[17:28:17.265]                 added <- setdiff(names, old_names)
[17:28:17.265]                 removed <- setdiff(old_names, names)
[17:28:17.265]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.265]                   envs[common]]
[17:28:17.265]                 NAMES <- toupper(changed)
[17:28:17.265]                 args <- list()
[17:28:17.265]                 for (kk in seq_along(NAMES)) {
[17:28:17.265]                   name <- changed[[kk]]
[17:28:17.265]                   NAME <- NAMES[[kk]]
[17:28:17.265]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.265]                     next
[17:28:17.265]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.265]                 }
[17:28:17.265]                 NAMES <- toupper(added)
[17:28:17.265]                 for (kk in seq_along(NAMES)) {
[17:28:17.265]                   name <- added[[kk]]
[17:28:17.265]                   NAME <- NAMES[[kk]]
[17:28:17.265]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.265]                     next
[17:28:17.265]                   args[[name]] <- ""
[17:28:17.265]                 }
[17:28:17.265]                 NAMES <- toupper(removed)
[17:28:17.265]                 for (kk in seq_along(NAMES)) {
[17:28:17.265]                   name <- removed[[kk]]
[17:28:17.265]                   NAME <- NAMES[[kk]]
[17:28:17.265]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.265]                     next
[17:28:17.265]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.265]                 }
[17:28:17.265]                 if (length(args) > 0) 
[17:28:17.265]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.265]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.265]             }
[17:28:17.265]             else {
[17:28:17.265]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.265]             }
[17:28:17.265]             {
[17:28:17.265]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.265]                   0L) {
[17:28:17.265]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.265]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.265]                   base::options(opts)
[17:28:17.265]                 }
[17:28:17.265]                 {
[17:28:17.265]                   {
[17:28:17.265]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:17.265]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:17.265]                     -1344458670L), envir = base::globalenv(), 
[17:28:17.265]                       inherits = FALSE)
[17:28:17.265]                     NULL
[17:28:17.265]                   }
[17:28:17.265]                   options(future.plan = NULL)
[17:28:17.265]                   if (is.na(NA_character_)) 
[17:28:17.265]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.265]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.265]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.265]                     .init = FALSE)
[17:28:17.265]                 }
[17:28:17.265]             }
[17:28:17.265]         }
[17:28:17.265]     })
[17:28:17.265]     if (TRUE) {
[17:28:17.265]         base::sink(type = "output", split = FALSE)
[17:28:17.265]         if (TRUE) {
[17:28:17.265]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.265]         }
[17:28:17.265]         else {
[17:28:17.265]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.265]         }
[17:28:17.265]         base::close(...future.stdout)
[17:28:17.265]         ...future.stdout <- NULL
[17:28:17.265]     }
[17:28:17.265]     ...future.result$conditions <- ...future.conditions
[17:28:17.265]     ...future.result$finished <- base::Sys.time()
[17:28:17.265]     ...future.result
[17:28:17.265] }
[17:28:17.269] assign_globals() ...
[17:28:17.269] List of 1
[17:28:17.269]  $ x: int [1:4] 0 1 2 3
[17:28:17.269]  - attr(*, "where")=List of 1
[17:28:17.269]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.269]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.269]  - attr(*, "resolved")= logi FALSE
[17:28:17.269]  - attr(*, "total_size")= num 64
[17:28:17.269]  - attr(*, "already-done")= logi TRUE
[17:28:17.272] - copied 'x' to environment
[17:28:17.272] assign_globals() ... done
[17:28:17.273] plan(): Setting new future strategy stack:
[17:28:17.273] List of future strategies:
[17:28:17.273] 1. sequential:
[17:28:17.273]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.273]    - tweaked: FALSE
[17:28:17.273]    - call: NULL
[17:28:17.274] plan(): nbrOfWorkers() = 1
[17:28:17.275] plan(): Setting new future strategy stack:
[17:28:17.275] List of future strategies:
[17:28:17.275] 1. sequential:
[17:28:17.275]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.275]    - tweaked: FALSE
[17:28:17.275]    - call: plan(strategy)
[17:28:17.275] plan(): nbrOfWorkers() = 1
[17:28:17.276] SequentialFuture started (and completed)
[17:28:17.276] - Launch lazy future ... done
[17:28:17.276] run() for 'SequentialFuture' ... done
[17:28:17.276] getGlobalsAndPackages() ...
[17:28:17.276] Searching for globals...
[17:28:17.278] - globals found: [3] '{', 'sample', 'x'
[17:28:17.278] Searching for globals ... DONE
[17:28:17.278] Resolving globals: FALSE
[17:28:17.279] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.280] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.280] - globals: [1] 'x'
[17:28:17.280] 
[17:28:17.280] getGlobalsAndPackages() ... DONE
[17:28:17.281] run() for 'Future' ...
[17:28:17.281] - state: 'created'
[17:28:17.281] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.281] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.281] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.282]   - Field: 'label'
[17:28:17.282]   - Field: 'local'
[17:28:17.282]   - Field: 'owner'
[17:28:17.282]   - Field: 'envir'
[17:28:17.282]   - Field: 'packages'
[17:28:17.282]   - Field: 'gc'
[17:28:17.283]   - Field: 'conditions'
[17:28:17.283]   - Field: 'expr'
[17:28:17.283]   - Field: 'uuid'
[17:28:17.283]   - Field: 'seed'
[17:28:17.283]   - Field: 'version'
[17:28:17.284]   - Field: 'result'
[17:28:17.284]   - Field: 'asynchronous'
[17:28:17.284]   - Field: 'calls'
[17:28:17.284]   - Field: 'globals'
[17:28:17.284]   - Field: 'stdout'
[17:28:17.284]   - Field: 'earlySignal'
[17:28:17.285]   - Field: 'lazy'
[17:28:17.285]   - Field: 'state'
[17:28:17.285] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.285] - Launch lazy future ...
[17:28:17.285] Packages needed by the future expression (n = 0): <none>
[17:28:17.285] Packages needed by future strategies (n = 0): <none>
[17:28:17.286] {
[17:28:17.286]     {
[17:28:17.286]         {
[17:28:17.286]             ...future.startTime <- base::Sys.time()
[17:28:17.286]             {
[17:28:17.286]                 {
[17:28:17.286]                   {
[17:28:17.286]                     {
[17:28:17.286]                       base::local({
[17:28:17.286]                         has_future <- base::requireNamespace("future", 
[17:28:17.286]                           quietly = TRUE)
[17:28:17.286]                         if (has_future) {
[17:28:17.286]                           ns <- base::getNamespace("future")
[17:28:17.286]                           version <- ns[[".package"]][["version"]]
[17:28:17.286]                           if (is.null(version)) 
[17:28:17.286]                             version <- utils::packageVersion("future")
[17:28:17.286]                         }
[17:28:17.286]                         else {
[17:28:17.286]                           version <- NULL
[17:28:17.286]                         }
[17:28:17.286]                         if (!has_future || version < "1.8.0") {
[17:28:17.286]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.286]                             "", base::R.version$version.string), 
[17:28:17.286]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:17.286]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.286]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.286]                               "release", "version")], collapse = " "), 
[17:28:17.286]                             hostname = base::Sys.info()[["nodename"]])
[17:28:17.286]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.286]                             info)
[17:28:17.286]                           info <- base::paste(info, collapse = "; ")
[17:28:17.286]                           if (!has_future) {
[17:28:17.286]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.286]                               info)
[17:28:17.286]                           }
[17:28:17.286]                           else {
[17:28:17.286]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.286]                               info, version)
[17:28:17.286]                           }
[17:28:17.286]                           base::stop(msg)
[17:28:17.286]                         }
[17:28:17.286]                       })
[17:28:17.286]                     }
[17:28:17.286]                     ...future.strategy.old <- future::plan("list")
[17:28:17.286]                     options(future.plan = NULL)
[17:28:17.286]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.286]                     future::plan("default", .cleanup = FALSE, 
[17:28:17.286]                       .init = FALSE)
[17:28:17.286]                   }
[17:28:17.286]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:28:17.286]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:28:17.286]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:28:17.286]                 }
[17:28:17.286]                 ...future.workdir <- getwd()
[17:28:17.286]             }
[17:28:17.286]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.286]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.286]         }
[17:28:17.286]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.286]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.286]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.286]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.286]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.286]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.286]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.286]             base::names(...future.oldOptions))
[17:28:17.286]     }
[17:28:17.286]     if (FALSE) {
[17:28:17.286]     }
[17:28:17.286]     else {
[17:28:17.286]         if (TRUE) {
[17:28:17.286]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.286]                 open = "w")
[17:28:17.286]         }
[17:28:17.286]         else {
[17:28:17.286]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.286]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.286]         }
[17:28:17.286]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.286]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.286]             base::sink(type = "output", split = FALSE)
[17:28:17.286]             base::close(...future.stdout)
[17:28:17.286]         }, add = TRUE)
[17:28:17.286]     }
[17:28:17.286]     ...future.frame <- base::sys.nframe()
[17:28:17.286]     ...future.conditions <- base::list()
[17:28:17.286]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.286]     if (FALSE) {
[17:28:17.286]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.286]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.286]     }
[17:28:17.286]     ...future.result <- base::tryCatch({
[17:28:17.286]         base::withCallingHandlers({
[17:28:17.286]             ...future.value <- base::withVisible(base::local({
[17:28:17.286]                 sample(x, size = 1L)
[17:28:17.286]             }))
[17:28:17.286]             future::FutureResult(value = ...future.value$value, 
[17:28:17.286]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.286]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.286]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.286]                     ...future.globalenv.names))
[17:28:17.286]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.286]         }, condition = base::local({
[17:28:17.286]             c <- base::c
[17:28:17.286]             inherits <- base::inherits
[17:28:17.286]             invokeRestart <- base::invokeRestart
[17:28:17.286]             length <- base::length
[17:28:17.286]             list <- base::list
[17:28:17.286]             seq.int <- base::seq.int
[17:28:17.286]             signalCondition <- base::signalCondition
[17:28:17.286]             sys.calls <- base::sys.calls
[17:28:17.286]             `[[` <- base::`[[`
[17:28:17.286]             `+` <- base::`+`
[17:28:17.286]             `<<-` <- base::`<<-`
[17:28:17.286]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.286]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.286]                   3L)]
[17:28:17.286]             }
[17:28:17.286]             function(cond) {
[17:28:17.286]                 is_error <- inherits(cond, "error")
[17:28:17.286]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.286]                   NULL)
[17:28:17.286]                 if (is_error) {
[17:28:17.286]                   sessionInformation <- function() {
[17:28:17.286]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.286]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.286]                       search = base::search(), system = base::Sys.info())
[17:28:17.286]                   }
[17:28:17.286]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.286]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.286]                     cond$call), session = sessionInformation(), 
[17:28:17.286]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.286]                   signalCondition(cond)
[17:28:17.286]                 }
[17:28:17.286]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.286]                 "immediateCondition"))) {
[17:28:17.286]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.286]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.286]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.286]                   if (TRUE && !signal) {
[17:28:17.286]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.286]                     {
[17:28:17.286]                       inherits <- base::inherits
[17:28:17.286]                       invokeRestart <- base::invokeRestart
[17:28:17.286]                       is.null <- base::is.null
[17:28:17.286]                       muffled <- FALSE
[17:28:17.286]                       if (inherits(cond, "message")) {
[17:28:17.286]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.286]                         if (muffled) 
[17:28:17.286]                           invokeRestart("muffleMessage")
[17:28:17.286]                       }
[17:28:17.286]                       else if (inherits(cond, "warning")) {
[17:28:17.286]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.286]                         if (muffled) 
[17:28:17.286]                           invokeRestart("muffleWarning")
[17:28:17.286]                       }
[17:28:17.286]                       else if (inherits(cond, "condition")) {
[17:28:17.286]                         if (!is.null(pattern)) {
[17:28:17.286]                           computeRestarts <- base::computeRestarts
[17:28:17.286]                           grepl <- base::grepl
[17:28:17.286]                           restarts <- computeRestarts(cond)
[17:28:17.286]                           for (restart in restarts) {
[17:28:17.286]                             name <- restart$name
[17:28:17.286]                             if (is.null(name)) 
[17:28:17.286]                               next
[17:28:17.286]                             if (!grepl(pattern, name)) 
[17:28:17.286]                               next
[17:28:17.286]                             invokeRestart(restart)
[17:28:17.286]                             muffled <- TRUE
[17:28:17.286]                             break
[17:28:17.286]                           }
[17:28:17.286]                         }
[17:28:17.286]                       }
[17:28:17.286]                       invisible(muffled)
[17:28:17.286]                     }
[17:28:17.286]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.286]                   }
[17:28:17.286]                 }
[17:28:17.286]                 else {
[17:28:17.286]                   if (TRUE) {
[17:28:17.286]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.286]                     {
[17:28:17.286]                       inherits <- base::inherits
[17:28:17.286]                       invokeRestart <- base::invokeRestart
[17:28:17.286]                       is.null <- base::is.null
[17:28:17.286]                       muffled <- FALSE
[17:28:17.286]                       if (inherits(cond, "message")) {
[17:28:17.286]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.286]                         if (muffled) 
[17:28:17.286]                           invokeRestart("muffleMessage")
[17:28:17.286]                       }
[17:28:17.286]                       else if (inherits(cond, "warning")) {
[17:28:17.286]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.286]                         if (muffled) 
[17:28:17.286]                           invokeRestart("muffleWarning")
[17:28:17.286]                       }
[17:28:17.286]                       else if (inherits(cond, "condition")) {
[17:28:17.286]                         if (!is.null(pattern)) {
[17:28:17.286]                           computeRestarts <- base::computeRestarts
[17:28:17.286]                           grepl <- base::grepl
[17:28:17.286]                           restarts <- computeRestarts(cond)
[17:28:17.286]                           for (restart in restarts) {
[17:28:17.286]                             name <- restart$name
[17:28:17.286]                             if (is.null(name)) 
[17:28:17.286]                               next
[17:28:17.286]                             if (!grepl(pattern, name)) 
[17:28:17.286]                               next
[17:28:17.286]                             invokeRestart(restart)
[17:28:17.286]                             muffled <- TRUE
[17:28:17.286]                             break
[17:28:17.286]                           }
[17:28:17.286]                         }
[17:28:17.286]                       }
[17:28:17.286]                       invisible(muffled)
[17:28:17.286]                     }
[17:28:17.286]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.286]                   }
[17:28:17.286]                 }
[17:28:17.286]             }
[17:28:17.286]         }))
[17:28:17.286]     }, error = function(ex) {
[17:28:17.286]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.286]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.286]                 ...future.rng), started = ...future.startTime, 
[17:28:17.286]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.286]             version = "1.8"), class = "FutureResult")
[17:28:17.286]     }, finally = {
[17:28:17.286]         if (!identical(...future.workdir, getwd())) 
[17:28:17.286]             setwd(...future.workdir)
[17:28:17.286]         {
[17:28:17.286]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.286]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.286]             }
[17:28:17.286]             base::options(...future.oldOptions)
[17:28:17.286]             if (.Platform$OS.type == "windows") {
[17:28:17.286]                 old_names <- names(...future.oldEnvVars)
[17:28:17.286]                 envs <- base::Sys.getenv()
[17:28:17.286]                 names <- names(envs)
[17:28:17.286]                 common <- intersect(names, old_names)
[17:28:17.286]                 added <- setdiff(names, old_names)
[17:28:17.286]                 removed <- setdiff(old_names, names)
[17:28:17.286]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.286]                   envs[common]]
[17:28:17.286]                 NAMES <- toupper(changed)
[17:28:17.286]                 args <- list()
[17:28:17.286]                 for (kk in seq_along(NAMES)) {
[17:28:17.286]                   name <- changed[[kk]]
[17:28:17.286]                   NAME <- NAMES[[kk]]
[17:28:17.286]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.286]                     next
[17:28:17.286]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.286]                 }
[17:28:17.286]                 NAMES <- toupper(added)
[17:28:17.286]                 for (kk in seq_along(NAMES)) {
[17:28:17.286]                   name <- added[[kk]]
[17:28:17.286]                   NAME <- NAMES[[kk]]
[17:28:17.286]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.286]                     next
[17:28:17.286]                   args[[name]] <- ""
[17:28:17.286]                 }
[17:28:17.286]                 NAMES <- toupper(removed)
[17:28:17.286]                 for (kk in seq_along(NAMES)) {
[17:28:17.286]                   name <- removed[[kk]]
[17:28:17.286]                   NAME <- NAMES[[kk]]
[17:28:17.286]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.286]                     next
[17:28:17.286]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.286]                 }
[17:28:17.286]                 if (length(args) > 0) 
[17:28:17.286]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.286]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.286]             }
[17:28:17.286]             else {
[17:28:17.286]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.286]             }
[17:28:17.286]             {
[17:28:17.286]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.286]                   0L) {
[17:28:17.286]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.286]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.286]                   base::options(opts)
[17:28:17.286]                 }
[17:28:17.286]                 {
[17:28:17.286]                   {
[17:28:17.286]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:17.286]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:17.286]                     -1344458670L), envir = base::globalenv(), 
[17:28:17.286]                       inherits = FALSE)
[17:28:17.286]                     NULL
[17:28:17.286]                   }
[17:28:17.286]                   options(future.plan = NULL)
[17:28:17.286]                   if (is.na(NA_character_)) 
[17:28:17.286]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.286]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.286]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.286]                     .init = FALSE)
[17:28:17.286]                 }
[17:28:17.286]             }
[17:28:17.286]         }
[17:28:17.286]     })
[17:28:17.286]     if (TRUE) {
[17:28:17.286]         base::sink(type = "output", split = FALSE)
[17:28:17.286]         if (TRUE) {
[17:28:17.286]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.286]         }
[17:28:17.286]         else {
[17:28:17.286]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.286]         }
[17:28:17.286]         base::close(...future.stdout)
[17:28:17.286]         ...future.stdout <- NULL
[17:28:17.286]     }
[17:28:17.286]     ...future.result$conditions <- ...future.conditions
[17:28:17.286]     ...future.result$finished <- base::Sys.time()
[17:28:17.286]     ...future.result
[17:28:17.286] }
[17:28:17.290] assign_globals() ...
[17:28:17.290] List of 1
[17:28:17.290]  $ x: int [1:4] 0 1 2 3
[17:28:17.290]  - attr(*, "where")=List of 1
[17:28:17.290]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.290]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.290]  - attr(*, "resolved")= logi FALSE
[17:28:17.290]  - attr(*, "total_size")= num 64
[17:28:17.290]  - attr(*, "already-done")= logi TRUE
[17:28:17.293] - copied 'x' to environment
[17:28:17.293] assign_globals() ... done
[17:28:17.293] plan(): Setting new future strategy stack:
[17:28:17.294] List of future strategies:
[17:28:17.294] 1. sequential:
[17:28:17.294]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.294]    - tweaked: FALSE
[17:28:17.294]    - call: NULL
[17:28:17.294] plan(): nbrOfWorkers() = 1
[17:28:17.295] plan(): Setting new future strategy stack:
[17:28:17.295] List of future strategies:
[17:28:17.295] 1. sequential:
[17:28:17.295]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.295]    - tweaked: FALSE
[17:28:17.295]    - call: plan(strategy)
[17:28:17.296] plan(): nbrOfWorkers() = 1
[17:28:17.296] SequentialFuture started (and completed)
[17:28:17.297] - Launch lazy future ... done
[17:28:17.297] run() for 'SequentialFuture' ... done
[17:28:17.297] getGlobalsAndPackages() ...
[17:28:17.297] Searching for globals...
[17:28:17.298] - globals found: [3] '{', 'sample', 'x'
[17:28:17.298] Searching for globals ... DONE
[17:28:17.299] Resolving globals: FALSE
[17:28:17.299] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.299] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.300] - globals: [1] 'x'
[17:28:17.300] 
[17:28:17.300] getGlobalsAndPackages() ... DONE
[17:28:17.300] run() for 'Future' ...
[17:28:17.301] - state: 'created'
[17:28:17.301] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.301] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.301] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.301]   - Field: 'label'
[17:28:17.302]   - Field: 'local'
[17:28:17.302]   - Field: 'owner'
[17:28:17.302]   - Field: 'envir'
[17:28:17.302]   - Field: 'packages'
[17:28:17.302]   - Field: 'gc'
[17:28:17.302]   - Field: 'conditions'
[17:28:17.303]   - Field: 'expr'
[17:28:17.303]   - Field: 'uuid'
[17:28:17.303]   - Field: 'seed'
[17:28:17.303]   - Field: 'version'
[17:28:17.303]   - Field: 'result'
[17:28:17.303]   - Field: 'asynchronous'
[17:28:17.304]   - Field: 'calls'
[17:28:17.304]   - Field: 'globals'
[17:28:17.304]   - Field: 'stdout'
[17:28:17.304]   - Field: 'earlySignal'
[17:28:17.304]   - Field: 'lazy'
[17:28:17.305]   - Field: 'state'
[17:28:17.305] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.305] - Launch lazy future ...
[17:28:17.305] Packages needed by the future expression (n = 0): <none>
[17:28:17.305] Packages needed by future strategies (n = 0): <none>
[17:28:17.306] {
[17:28:17.306]     {
[17:28:17.306]         {
[17:28:17.306]             ...future.startTime <- base::Sys.time()
[17:28:17.306]             {
[17:28:17.306]                 {
[17:28:17.306]                   {
[17:28:17.306]                     {
[17:28:17.306]                       base::local({
[17:28:17.306]                         has_future <- base::requireNamespace("future", 
[17:28:17.306]                           quietly = TRUE)
[17:28:17.306]                         if (has_future) {
[17:28:17.306]                           ns <- base::getNamespace("future")
[17:28:17.306]                           version <- ns[[".package"]][["version"]]
[17:28:17.306]                           if (is.null(version)) 
[17:28:17.306]                             version <- utils::packageVersion("future")
[17:28:17.306]                         }
[17:28:17.306]                         else {
[17:28:17.306]                           version <- NULL
[17:28:17.306]                         }
[17:28:17.306]                         if (!has_future || version < "1.8.0") {
[17:28:17.306]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.306]                             "", base::R.version$version.string), 
[17:28:17.306]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:17.306]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.306]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.306]                               "release", "version")], collapse = " "), 
[17:28:17.306]                             hostname = base::Sys.info()[["nodename"]])
[17:28:17.306]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.306]                             info)
[17:28:17.306]                           info <- base::paste(info, collapse = "; ")
[17:28:17.306]                           if (!has_future) {
[17:28:17.306]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.306]                               info)
[17:28:17.306]                           }
[17:28:17.306]                           else {
[17:28:17.306]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.306]                               info, version)
[17:28:17.306]                           }
[17:28:17.306]                           base::stop(msg)
[17:28:17.306]                         }
[17:28:17.306]                       })
[17:28:17.306]                     }
[17:28:17.306]                     ...future.strategy.old <- future::plan("list")
[17:28:17.306]                     options(future.plan = NULL)
[17:28:17.306]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.306]                     future::plan("default", .cleanup = FALSE, 
[17:28:17.306]                       .init = FALSE)
[17:28:17.306]                   }
[17:28:17.306]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:28:17.306]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:28:17.306]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:28:17.306]                 }
[17:28:17.306]                 ...future.workdir <- getwd()
[17:28:17.306]             }
[17:28:17.306]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.306]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.306]         }
[17:28:17.306]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.306]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.306]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.306]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.306]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.306]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.306]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.306]             base::names(...future.oldOptions))
[17:28:17.306]     }
[17:28:17.306]     if (FALSE) {
[17:28:17.306]     }
[17:28:17.306]     else {
[17:28:17.306]         if (TRUE) {
[17:28:17.306]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.306]                 open = "w")
[17:28:17.306]         }
[17:28:17.306]         else {
[17:28:17.306]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.306]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.306]         }
[17:28:17.306]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.306]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.306]             base::sink(type = "output", split = FALSE)
[17:28:17.306]             base::close(...future.stdout)
[17:28:17.306]         }, add = TRUE)
[17:28:17.306]     }
[17:28:17.306]     ...future.frame <- base::sys.nframe()
[17:28:17.306]     ...future.conditions <- base::list()
[17:28:17.306]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.306]     if (FALSE) {
[17:28:17.306]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.306]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.306]     }
[17:28:17.306]     ...future.result <- base::tryCatch({
[17:28:17.306]         base::withCallingHandlers({
[17:28:17.306]             ...future.value <- base::withVisible(base::local({
[17:28:17.306]                 sample(x, size = 1L)
[17:28:17.306]             }))
[17:28:17.306]             future::FutureResult(value = ...future.value$value, 
[17:28:17.306]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.306]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.306]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.306]                     ...future.globalenv.names))
[17:28:17.306]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.306]         }, condition = base::local({
[17:28:17.306]             c <- base::c
[17:28:17.306]             inherits <- base::inherits
[17:28:17.306]             invokeRestart <- base::invokeRestart
[17:28:17.306]             length <- base::length
[17:28:17.306]             list <- base::list
[17:28:17.306]             seq.int <- base::seq.int
[17:28:17.306]             signalCondition <- base::signalCondition
[17:28:17.306]             sys.calls <- base::sys.calls
[17:28:17.306]             `[[` <- base::`[[`
[17:28:17.306]             `+` <- base::`+`
[17:28:17.306]             `<<-` <- base::`<<-`
[17:28:17.306]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.306]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.306]                   3L)]
[17:28:17.306]             }
[17:28:17.306]             function(cond) {
[17:28:17.306]                 is_error <- inherits(cond, "error")
[17:28:17.306]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.306]                   NULL)
[17:28:17.306]                 if (is_error) {
[17:28:17.306]                   sessionInformation <- function() {
[17:28:17.306]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.306]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.306]                       search = base::search(), system = base::Sys.info())
[17:28:17.306]                   }
[17:28:17.306]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.306]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.306]                     cond$call), session = sessionInformation(), 
[17:28:17.306]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.306]                   signalCondition(cond)
[17:28:17.306]                 }
[17:28:17.306]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.306]                 "immediateCondition"))) {
[17:28:17.306]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.306]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.306]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.306]                   if (TRUE && !signal) {
[17:28:17.306]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.306]                     {
[17:28:17.306]                       inherits <- base::inherits
[17:28:17.306]                       invokeRestart <- base::invokeRestart
[17:28:17.306]                       is.null <- base::is.null
[17:28:17.306]                       muffled <- FALSE
[17:28:17.306]                       if (inherits(cond, "message")) {
[17:28:17.306]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.306]                         if (muffled) 
[17:28:17.306]                           invokeRestart("muffleMessage")
[17:28:17.306]                       }
[17:28:17.306]                       else if (inherits(cond, "warning")) {
[17:28:17.306]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.306]                         if (muffled) 
[17:28:17.306]                           invokeRestart("muffleWarning")
[17:28:17.306]                       }
[17:28:17.306]                       else if (inherits(cond, "condition")) {
[17:28:17.306]                         if (!is.null(pattern)) {
[17:28:17.306]                           computeRestarts <- base::computeRestarts
[17:28:17.306]                           grepl <- base::grepl
[17:28:17.306]                           restarts <- computeRestarts(cond)
[17:28:17.306]                           for (restart in restarts) {
[17:28:17.306]                             name <- restart$name
[17:28:17.306]                             if (is.null(name)) 
[17:28:17.306]                               next
[17:28:17.306]                             if (!grepl(pattern, name)) 
[17:28:17.306]                               next
[17:28:17.306]                             invokeRestart(restart)
[17:28:17.306]                             muffled <- TRUE
[17:28:17.306]                             break
[17:28:17.306]                           }
[17:28:17.306]                         }
[17:28:17.306]                       }
[17:28:17.306]                       invisible(muffled)
[17:28:17.306]                     }
[17:28:17.306]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.306]                   }
[17:28:17.306]                 }
[17:28:17.306]                 else {
[17:28:17.306]                   if (TRUE) {
[17:28:17.306]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.306]                     {
[17:28:17.306]                       inherits <- base::inherits
[17:28:17.306]                       invokeRestart <- base::invokeRestart
[17:28:17.306]                       is.null <- base::is.null
[17:28:17.306]                       muffled <- FALSE
[17:28:17.306]                       if (inherits(cond, "message")) {
[17:28:17.306]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.306]                         if (muffled) 
[17:28:17.306]                           invokeRestart("muffleMessage")
[17:28:17.306]                       }
[17:28:17.306]                       else if (inherits(cond, "warning")) {
[17:28:17.306]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.306]                         if (muffled) 
[17:28:17.306]                           invokeRestart("muffleWarning")
[17:28:17.306]                       }
[17:28:17.306]                       else if (inherits(cond, "condition")) {
[17:28:17.306]                         if (!is.null(pattern)) {
[17:28:17.306]                           computeRestarts <- base::computeRestarts
[17:28:17.306]                           grepl <- base::grepl
[17:28:17.306]                           restarts <- computeRestarts(cond)
[17:28:17.306]                           for (restart in restarts) {
[17:28:17.306]                             name <- restart$name
[17:28:17.306]                             if (is.null(name)) 
[17:28:17.306]                               next
[17:28:17.306]                             if (!grepl(pattern, name)) 
[17:28:17.306]                               next
[17:28:17.306]                             invokeRestart(restart)
[17:28:17.306]                             muffled <- TRUE
[17:28:17.306]                             break
[17:28:17.306]                           }
[17:28:17.306]                         }
[17:28:17.306]                       }
[17:28:17.306]                       invisible(muffled)
[17:28:17.306]                     }
[17:28:17.306]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.306]                   }
[17:28:17.306]                 }
[17:28:17.306]             }
[17:28:17.306]         }))
[17:28:17.306]     }, error = function(ex) {
[17:28:17.306]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.306]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.306]                 ...future.rng), started = ...future.startTime, 
[17:28:17.306]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.306]             version = "1.8"), class = "FutureResult")
[17:28:17.306]     }, finally = {
[17:28:17.306]         if (!identical(...future.workdir, getwd())) 
[17:28:17.306]             setwd(...future.workdir)
[17:28:17.306]         {
[17:28:17.306]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.306]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.306]             }
[17:28:17.306]             base::options(...future.oldOptions)
[17:28:17.306]             if (.Platform$OS.type == "windows") {
[17:28:17.306]                 old_names <- names(...future.oldEnvVars)
[17:28:17.306]                 envs <- base::Sys.getenv()
[17:28:17.306]                 names <- names(envs)
[17:28:17.306]                 common <- intersect(names, old_names)
[17:28:17.306]                 added <- setdiff(names, old_names)
[17:28:17.306]                 removed <- setdiff(old_names, names)
[17:28:17.306]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.306]                   envs[common]]
[17:28:17.306]                 NAMES <- toupper(changed)
[17:28:17.306]                 args <- list()
[17:28:17.306]                 for (kk in seq_along(NAMES)) {
[17:28:17.306]                   name <- changed[[kk]]
[17:28:17.306]                   NAME <- NAMES[[kk]]
[17:28:17.306]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.306]                     next
[17:28:17.306]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.306]                 }
[17:28:17.306]                 NAMES <- toupper(added)
[17:28:17.306]                 for (kk in seq_along(NAMES)) {
[17:28:17.306]                   name <- added[[kk]]
[17:28:17.306]                   NAME <- NAMES[[kk]]
[17:28:17.306]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.306]                     next
[17:28:17.306]                   args[[name]] <- ""
[17:28:17.306]                 }
[17:28:17.306]                 NAMES <- toupper(removed)
[17:28:17.306]                 for (kk in seq_along(NAMES)) {
[17:28:17.306]                   name <- removed[[kk]]
[17:28:17.306]                   NAME <- NAMES[[kk]]
[17:28:17.306]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.306]                     next
[17:28:17.306]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.306]                 }
[17:28:17.306]                 if (length(args) > 0) 
[17:28:17.306]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.306]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.306]             }
[17:28:17.306]             else {
[17:28:17.306]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.306]             }
[17:28:17.306]             {
[17:28:17.306]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.306]                   0L) {
[17:28:17.306]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.306]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.306]                   base::options(opts)
[17:28:17.306]                 }
[17:28:17.306]                 {
[17:28:17.306]                   {
[17:28:17.306]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:17.306]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:17.306]                     -1344458670L), envir = base::globalenv(), 
[17:28:17.306]                       inherits = FALSE)
[17:28:17.306]                     NULL
[17:28:17.306]                   }
[17:28:17.306]                   options(future.plan = NULL)
[17:28:17.306]                   if (is.na(NA_character_)) 
[17:28:17.306]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.306]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.306]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.306]                     .init = FALSE)
[17:28:17.306]                 }
[17:28:17.306]             }
[17:28:17.306]         }
[17:28:17.306]     })
[17:28:17.306]     if (TRUE) {
[17:28:17.306]         base::sink(type = "output", split = FALSE)
[17:28:17.306]         if (TRUE) {
[17:28:17.306]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.306]         }
[17:28:17.306]         else {
[17:28:17.306]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.306]         }
[17:28:17.306]         base::close(...future.stdout)
[17:28:17.306]         ...future.stdout <- NULL
[17:28:17.306]     }
[17:28:17.306]     ...future.result$conditions <- ...future.conditions
[17:28:17.306]     ...future.result$finished <- base::Sys.time()
[17:28:17.306]     ...future.result
[17:28:17.306] }
[17:28:17.310] assign_globals() ...
[17:28:17.310] List of 1
[17:28:17.310]  $ x: int [1:4] 0 1 2 3
[17:28:17.310]  - attr(*, "where")=List of 1
[17:28:17.310]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.310]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.310]  - attr(*, "resolved")= logi FALSE
[17:28:17.310]  - attr(*, "total_size")= num 64
[17:28:17.310]  - attr(*, "already-done")= logi TRUE
[17:28:17.313] - copied 'x' to environment
[17:28:17.314] assign_globals() ... done
[17:28:17.314] plan(): Setting new future strategy stack:
[17:28:17.314] List of future strategies:
[17:28:17.314] 1. sequential:
[17:28:17.314]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.314]    - tweaked: FALSE
[17:28:17.314]    - call: NULL
[17:28:17.315] plan(): nbrOfWorkers() = 1
[17:28:17.316] plan(): Setting new future strategy stack:
[17:28:17.316] List of future strategies:
[17:28:17.316] 1. sequential:
[17:28:17.316]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.316]    - tweaked: FALSE
[17:28:17.316]    - call: plan(strategy)
[17:28:17.317] plan(): nbrOfWorkers() = 1
[17:28:17.317] SequentialFuture started (and completed)
[17:28:17.317] - Launch lazy future ... done
[17:28:17.317] run() for 'SequentialFuture' ... done
[17:28:17.318] resolve() on list ...
[17:28:17.318]  recursive: 0
[17:28:17.318]  length: 4
[17:28:17.318] 
[17:28:17.318] resolved() for 'SequentialFuture' ...
[17:28:17.318] - state: 'finished'
[17:28:17.319] - run: TRUE
[17:28:17.319] - result: 'FutureResult'
[17:28:17.319] resolved() for 'SequentialFuture' ... done
[17:28:17.319] Future #1
[17:28:17.319] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:28:17.319] - nx: 4
[17:28:17.320] - relay: TRUE
[17:28:17.320] - stdout: TRUE
[17:28:17.320] - signal: TRUE
[17:28:17.320] - resignal: FALSE
[17:28:17.320] - force: TRUE
[17:28:17.320] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.320] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.321]  - until=1
[17:28:17.321]  - relaying element #1
[17:28:17.321] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.321] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.321] signalConditionsASAP(SequentialFuture, pos=1) ... done
[17:28:17.322]  length: 3 (resolved future 1)
[17:28:17.322] resolved() for 'SequentialFuture' ...
[17:28:17.322] - state: 'finished'
[17:28:17.322] - run: TRUE
[17:28:17.322] - result: 'FutureResult'
[17:28:17.322] resolved() for 'SequentialFuture' ... done
[17:28:17.323] Future #2
[17:28:17.323] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:28:17.323] - nx: 4
[17:28:17.323] - relay: TRUE
[17:28:17.323] - stdout: TRUE
[17:28:17.323] - signal: TRUE
[17:28:17.324] - resignal: FALSE
[17:28:17.324] - force: TRUE
[17:28:17.324] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.324] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.324]  - until=2
[17:28:17.324]  - relaying element #2
[17:28:17.325] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.325] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.325] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:28:17.325]  length: 2 (resolved future 2)
[17:28:17.325] resolved() for 'SequentialFuture' ...
[17:28:17.325] - state: 'finished'
[17:28:17.326] - run: TRUE
[17:28:17.326] - result: 'FutureResult'
[17:28:17.326] resolved() for 'SequentialFuture' ... done
[17:28:17.326] Future #3
[17:28:17.326] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:28:17.327] - nx: 4
[17:28:17.327] - relay: TRUE
[17:28:17.327] - stdout: TRUE
[17:28:17.327] - signal: TRUE
[17:28:17.327] - resignal: FALSE
[17:28:17.327] - force: TRUE
[17:28:17.327] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.328] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.328]  - until=3
[17:28:17.328]  - relaying element #3
[17:28:17.328] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.328] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.328] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:28:17.329]  length: 1 (resolved future 3)
[17:28:17.329] resolved() for 'SequentialFuture' ...
[17:28:17.329] - state: 'finished'
[17:28:17.329] - run: TRUE
[17:28:17.329] - result: 'FutureResult'
[17:28:17.330] resolved() for 'SequentialFuture' ... done
[17:28:17.330] Future #4
[17:28:17.330] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:28:17.330] - nx: 4
[17:28:17.330] - relay: TRUE
[17:28:17.330] - stdout: TRUE
[17:28:17.331] - signal: TRUE
[17:28:17.331] - resignal: FALSE
[17:28:17.331] - force: TRUE
[17:28:17.331] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.331] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.331]  - until=4
[17:28:17.331]  - relaying element #4
[17:28:17.332] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.332] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.332] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:28:17.332]  length: 0 (resolved future 4)
[17:28:17.332] Relaying remaining futures
[17:28:17.333] signalConditionsASAP(NULL, pos=0) ...
[17:28:17.333] - nx: 4
[17:28:17.333] - relay: TRUE
[17:28:17.333] - stdout: TRUE
[17:28:17.333] - signal: TRUE
[17:28:17.333] - resignal: FALSE
[17:28:17.333] - force: TRUE
[17:28:17.334] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.334] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:28:17.334] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.334] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.334] signalConditionsASAP(NULL, pos=0) ... done
[17:28:17.334] resolve() on list ... DONE
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[17:28:17.335] getGlobalsAndPackages() ...
[17:28:17.335] Searching for globals...
[17:28:17.336] - globals found: [3] '{', 'sample', 'x'
[17:28:17.337] Searching for globals ... DONE
[17:28:17.337] Resolving globals: FALSE
[17:28:17.337] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.338] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.338] - globals: [1] 'x'
[17:28:17.338] 
[17:28:17.338] getGlobalsAndPackages() ... DONE
[17:28:17.338] run() for 'Future' ...
[17:28:17.339] - state: 'created'
[17:28:17.339] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.339] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.339] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.340]   - Field: 'label'
[17:28:17.340]   - Field: 'local'
[17:28:17.340]   - Field: 'owner'
[17:28:17.340]   - Field: 'envir'
[17:28:17.340]   - Field: 'packages'
[17:28:17.340]   - Field: 'gc'
[17:28:17.341]   - Field: 'conditions'
[17:28:17.341]   - Field: 'expr'
[17:28:17.341]   - Field: 'uuid'
[17:28:17.341]   - Field: 'seed'
[17:28:17.341]   - Field: 'version'
[17:28:17.341]   - Field: 'result'
[17:28:17.342]   - Field: 'asynchronous'
[17:28:17.342]   - Field: 'calls'
[17:28:17.342]   - Field: 'globals'
[17:28:17.342]   - Field: 'stdout'
[17:28:17.342]   - Field: 'earlySignal'
[17:28:17.342]   - Field: 'lazy'
[17:28:17.343]   - Field: 'state'
[17:28:17.343] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.344] - Launch lazy future ...
[17:28:17.344] Packages needed by the future expression (n = 0): <none>
[17:28:17.345] Packages needed by future strategies (n = 0): <none>
[17:28:17.345] {
[17:28:17.345]     {
[17:28:17.345]         {
[17:28:17.345]             ...future.startTime <- base::Sys.time()
[17:28:17.345]             {
[17:28:17.345]                 {
[17:28:17.345]                   {
[17:28:17.345]                     base::local({
[17:28:17.345]                       has_future <- base::requireNamespace("future", 
[17:28:17.345]                         quietly = TRUE)
[17:28:17.345]                       if (has_future) {
[17:28:17.345]                         ns <- base::getNamespace("future")
[17:28:17.345]                         version <- ns[[".package"]][["version"]]
[17:28:17.345]                         if (is.null(version)) 
[17:28:17.345]                           version <- utils::packageVersion("future")
[17:28:17.345]                       }
[17:28:17.345]                       else {
[17:28:17.345]                         version <- NULL
[17:28:17.345]                       }
[17:28:17.345]                       if (!has_future || version < "1.8.0") {
[17:28:17.345]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.345]                           "", base::R.version$version.string), 
[17:28:17.345]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.345]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.345]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.345]                             "release", "version")], collapse = " "), 
[17:28:17.345]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.345]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.345]                           info)
[17:28:17.345]                         info <- base::paste(info, collapse = "; ")
[17:28:17.345]                         if (!has_future) {
[17:28:17.345]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.345]                             info)
[17:28:17.345]                         }
[17:28:17.345]                         else {
[17:28:17.345]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.345]                             info, version)
[17:28:17.345]                         }
[17:28:17.345]                         base::stop(msg)
[17:28:17.345]                       }
[17:28:17.345]                     })
[17:28:17.345]                   }
[17:28:17.345]                   ...future.strategy.old <- future::plan("list")
[17:28:17.345]                   options(future.plan = NULL)
[17:28:17.345]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.345]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.345]                 }
[17:28:17.345]                 ...future.workdir <- getwd()
[17:28:17.345]             }
[17:28:17.345]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.345]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.345]         }
[17:28:17.345]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.345]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.345]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.345]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.345]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.345]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.345]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.345]             base::names(...future.oldOptions))
[17:28:17.345]     }
[17:28:17.345]     if (FALSE) {
[17:28:17.345]     }
[17:28:17.345]     else {
[17:28:17.345]         if (TRUE) {
[17:28:17.345]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.345]                 open = "w")
[17:28:17.345]         }
[17:28:17.345]         else {
[17:28:17.345]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.345]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.345]         }
[17:28:17.345]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.345]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.345]             base::sink(type = "output", split = FALSE)
[17:28:17.345]             base::close(...future.stdout)
[17:28:17.345]         }, add = TRUE)
[17:28:17.345]     }
[17:28:17.345]     ...future.frame <- base::sys.nframe()
[17:28:17.345]     ...future.conditions <- base::list()
[17:28:17.345]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.345]     if (FALSE) {
[17:28:17.345]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.345]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.345]     }
[17:28:17.345]     ...future.result <- base::tryCatch({
[17:28:17.345]         base::withCallingHandlers({
[17:28:17.345]             ...future.value <- base::withVisible(base::local({
[17:28:17.345]                 sample(x, size = 1L)
[17:28:17.345]             }))
[17:28:17.345]             future::FutureResult(value = ...future.value$value, 
[17:28:17.345]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.345]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.345]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.345]                     ...future.globalenv.names))
[17:28:17.345]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.345]         }, condition = base::local({
[17:28:17.345]             c <- base::c
[17:28:17.345]             inherits <- base::inherits
[17:28:17.345]             invokeRestart <- base::invokeRestart
[17:28:17.345]             length <- base::length
[17:28:17.345]             list <- base::list
[17:28:17.345]             seq.int <- base::seq.int
[17:28:17.345]             signalCondition <- base::signalCondition
[17:28:17.345]             sys.calls <- base::sys.calls
[17:28:17.345]             `[[` <- base::`[[`
[17:28:17.345]             `+` <- base::`+`
[17:28:17.345]             `<<-` <- base::`<<-`
[17:28:17.345]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.345]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.345]                   3L)]
[17:28:17.345]             }
[17:28:17.345]             function(cond) {
[17:28:17.345]                 is_error <- inherits(cond, "error")
[17:28:17.345]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.345]                   NULL)
[17:28:17.345]                 if (is_error) {
[17:28:17.345]                   sessionInformation <- function() {
[17:28:17.345]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.345]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.345]                       search = base::search(), system = base::Sys.info())
[17:28:17.345]                   }
[17:28:17.345]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.345]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.345]                     cond$call), session = sessionInformation(), 
[17:28:17.345]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.345]                   signalCondition(cond)
[17:28:17.345]                 }
[17:28:17.345]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.345]                 "immediateCondition"))) {
[17:28:17.345]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.345]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.345]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.345]                   if (TRUE && !signal) {
[17:28:17.345]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.345]                     {
[17:28:17.345]                       inherits <- base::inherits
[17:28:17.345]                       invokeRestart <- base::invokeRestart
[17:28:17.345]                       is.null <- base::is.null
[17:28:17.345]                       muffled <- FALSE
[17:28:17.345]                       if (inherits(cond, "message")) {
[17:28:17.345]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.345]                         if (muffled) 
[17:28:17.345]                           invokeRestart("muffleMessage")
[17:28:17.345]                       }
[17:28:17.345]                       else if (inherits(cond, "warning")) {
[17:28:17.345]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.345]                         if (muffled) 
[17:28:17.345]                           invokeRestart("muffleWarning")
[17:28:17.345]                       }
[17:28:17.345]                       else if (inherits(cond, "condition")) {
[17:28:17.345]                         if (!is.null(pattern)) {
[17:28:17.345]                           computeRestarts <- base::computeRestarts
[17:28:17.345]                           grepl <- base::grepl
[17:28:17.345]                           restarts <- computeRestarts(cond)
[17:28:17.345]                           for (restart in restarts) {
[17:28:17.345]                             name <- restart$name
[17:28:17.345]                             if (is.null(name)) 
[17:28:17.345]                               next
[17:28:17.345]                             if (!grepl(pattern, name)) 
[17:28:17.345]                               next
[17:28:17.345]                             invokeRestart(restart)
[17:28:17.345]                             muffled <- TRUE
[17:28:17.345]                             break
[17:28:17.345]                           }
[17:28:17.345]                         }
[17:28:17.345]                       }
[17:28:17.345]                       invisible(muffled)
[17:28:17.345]                     }
[17:28:17.345]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.345]                   }
[17:28:17.345]                 }
[17:28:17.345]                 else {
[17:28:17.345]                   if (TRUE) {
[17:28:17.345]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.345]                     {
[17:28:17.345]                       inherits <- base::inherits
[17:28:17.345]                       invokeRestart <- base::invokeRestart
[17:28:17.345]                       is.null <- base::is.null
[17:28:17.345]                       muffled <- FALSE
[17:28:17.345]                       if (inherits(cond, "message")) {
[17:28:17.345]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.345]                         if (muffled) 
[17:28:17.345]                           invokeRestart("muffleMessage")
[17:28:17.345]                       }
[17:28:17.345]                       else if (inherits(cond, "warning")) {
[17:28:17.345]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.345]                         if (muffled) 
[17:28:17.345]                           invokeRestart("muffleWarning")
[17:28:17.345]                       }
[17:28:17.345]                       else if (inherits(cond, "condition")) {
[17:28:17.345]                         if (!is.null(pattern)) {
[17:28:17.345]                           computeRestarts <- base::computeRestarts
[17:28:17.345]                           grepl <- base::grepl
[17:28:17.345]                           restarts <- computeRestarts(cond)
[17:28:17.345]                           for (restart in restarts) {
[17:28:17.345]                             name <- restart$name
[17:28:17.345]                             if (is.null(name)) 
[17:28:17.345]                               next
[17:28:17.345]                             if (!grepl(pattern, name)) 
[17:28:17.345]                               next
[17:28:17.345]                             invokeRestart(restart)
[17:28:17.345]                             muffled <- TRUE
[17:28:17.345]                             break
[17:28:17.345]                           }
[17:28:17.345]                         }
[17:28:17.345]                       }
[17:28:17.345]                       invisible(muffled)
[17:28:17.345]                     }
[17:28:17.345]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.345]                   }
[17:28:17.345]                 }
[17:28:17.345]             }
[17:28:17.345]         }))
[17:28:17.345]     }, error = function(ex) {
[17:28:17.345]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.345]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.345]                 ...future.rng), started = ...future.startTime, 
[17:28:17.345]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.345]             version = "1.8"), class = "FutureResult")
[17:28:17.345]     }, finally = {
[17:28:17.345]         if (!identical(...future.workdir, getwd())) 
[17:28:17.345]             setwd(...future.workdir)
[17:28:17.345]         {
[17:28:17.345]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.345]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.345]             }
[17:28:17.345]             base::options(...future.oldOptions)
[17:28:17.345]             if (.Platform$OS.type == "windows") {
[17:28:17.345]                 old_names <- names(...future.oldEnvVars)
[17:28:17.345]                 envs <- base::Sys.getenv()
[17:28:17.345]                 names <- names(envs)
[17:28:17.345]                 common <- intersect(names, old_names)
[17:28:17.345]                 added <- setdiff(names, old_names)
[17:28:17.345]                 removed <- setdiff(old_names, names)
[17:28:17.345]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.345]                   envs[common]]
[17:28:17.345]                 NAMES <- toupper(changed)
[17:28:17.345]                 args <- list()
[17:28:17.345]                 for (kk in seq_along(NAMES)) {
[17:28:17.345]                   name <- changed[[kk]]
[17:28:17.345]                   NAME <- NAMES[[kk]]
[17:28:17.345]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.345]                     next
[17:28:17.345]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.345]                 }
[17:28:17.345]                 NAMES <- toupper(added)
[17:28:17.345]                 for (kk in seq_along(NAMES)) {
[17:28:17.345]                   name <- added[[kk]]
[17:28:17.345]                   NAME <- NAMES[[kk]]
[17:28:17.345]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.345]                     next
[17:28:17.345]                   args[[name]] <- ""
[17:28:17.345]                 }
[17:28:17.345]                 NAMES <- toupper(removed)
[17:28:17.345]                 for (kk in seq_along(NAMES)) {
[17:28:17.345]                   name <- removed[[kk]]
[17:28:17.345]                   NAME <- NAMES[[kk]]
[17:28:17.345]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.345]                     next
[17:28:17.345]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.345]                 }
[17:28:17.345]                 if (length(args) > 0) 
[17:28:17.345]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.345]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.345]             }
[17:28:17.345]             else {
[17:28:17.345]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.345]             }
[17:28:17.345]             {
[17:28:17.345]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.345]                   0L) {
[17:28:17.345]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.345]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.345]                   base::options(opts)
[17:28:17.345]                 }
[17:28:17.345]                 {
[17:28:17.345]                   {
[17:28:17.345]                     base::assign(".Random.seed", c(10407L, 1229781135L, 
[17:28:17.345]                     -1383414008L, -272798089L, 1000427506L, 167001878L, 
[17:28:17.345]                     -1555199413L), envir = base::globalenv(), 
[17:28:17.345]                       inherits = FALSE)
[17:28:17.345]                     NULL
[17:28:17.345]                   }
[17:28:17.345]                   options(future.plan = NULL)
[17:28:17.345]                   if (is.na(NA_character_)) 
[17:28:17.345]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.345]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.345]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.345]                     .init = FALSE)
[17:28:17.345]                 }
[17:28:17.345]             }
[17:28:17.345]         }
[17:28:17.345]     })
[17:28:17.345]     if (TRUE) {
[17:28:17.345]         base::sink(type = "output", split = FALSE)
[17:28:17.345]         if (TRUE) {
[17:28:17.345]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.345]         }
[17:28:17.345]         else {
[17:28:17.345]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.345]         }
[17:28:17.345]         base::close(...future.stdout)
[17:28:17.345]         ...future.stdout <- NULL
[17:28:17.345]     }
[17:28:17.345]     ...future.result$conditions <- ...future.conditions
[17:28:17.345]     ...future.result$finished <- base::Sys.time()
[17:28:17.345]     ...future.result
[17:28:17.345] }
[17:28:17.349] assign_globals() ...
[17:28:17.349] List of 1
[17:28:17.349]  $ x: int [1:4] 0 1 2 3
[17:28:17.349]  - attr(*, "where")=List of 1
[17:28:17.349]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.349]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.349]  - attr(*, "resolved")= logi FALSE
[17:28:17.349]  - attr(*, "total_size")= num 64
[17:28:17.349]  - attr(*, "already-done")= logi TRUE
[17:28:17.353] - copied 'x' to environment
[17:28:17.353] assign_globals() ... done
[17:28:17.353] plan(): Setting new future strategy stack:
[17:28:17.353] List of future strategies:
[17:28:17.353] 1. sequential:
[17:28:17.353]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.353]    - tweaked: FALSE
[17:28:17.353]    - call: NULL
[17:28:17.354] plan(): nbrOfWorkers() = 1
[17:28:17.355] plan(): Setting new future strategy stack:
[17:28:17.355] List of future strategies:
[17:28:17.355] 1. sequential:
[17:28:17.355]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.355]    - tweaked: FALSE
[17:28:17.355]    - call: plan(strategy)
[17:28:17.356] plan(): nbrOfWorkers() = 1
[17:28:17.356] SequentialFuture started (and completed)
[17:28:17.356] - Launch lazy future ... done
[17:28:17.357] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-412784'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x0000026673a19b50
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.358] getGlobalsAndPackages() ...
[17:28:17.358] Searching for globals...
[17:28:17.359] - globals found: [3] '{', 'sample', 'x'
[17:28:17.359] Searching for globals ... DONE
[17:28:17.360] Resolving globals: FALSE
[17:28:17.360] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.361] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.361] - globals: [1] 'x'
[17:28:17.361] 
[17:28:17.361] getGlobalsAndPackages() ... DONE
[17:28:17.361] run() for 'Future' ...
[17:28:17.362] - state: 'created'
[17:28:17.362] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.362] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.362] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.363]   - Field: 'label'
[17:28:17.363]   - Field: 'local'
[17:28:17.363]   - Field: 'owner'
[17:28:17.363]   - Field: 'envir'
[17:28:17.363]   - Field: 'packages'
[17:28:17.364]   - Field: 'gc'
[17:28:17.364]   - Field: 'conditions'
[17:28:17.364]   - Field: 'expr'
[17:28:17.364]   - Field: 'uuid'
[17:28:17.364]   - Field: 'seed'
[17:28:17.364]   - Field: 'version'
[17:28:17.365]   - Field: 'result'
[17:28:17.365]   - Field: 'asynchronous'
[17:28:17.365]   - Field: 'calls'
[17:28:17.365]   - Field: 'globals'
[17:28:17.365]   - Field: 'stdout'
[17:28:17.366]   - Field: 'earlySignal'
[17:28:17.366]   - Field: 'lazy'
[17:28:17.366]   - Field: 'state'
[17:28:17.366] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.366] - Launch lazy future ...
[17:28:17.366] Packages needed by the future expression (n = 0): <none>
[17:28:17.367] Packages needed by future strategies (n = 0): <none>
[17:28:17.367] {
[17:28:17.367]     {
[17:28:17.367]         {
[17:28:17.367]             ...future.startTime <- base::Sys.time()
[17:28:17.367]             {
[17:28:17.367]                 {
[17:28:17.367]                   {
[17:28:17.367]                     base::local({
[17:28:17.367]                       has_future <- base::requireNamespace("future", 
[17:28:17.367]                         quietly = TRUE)
[17:28:17.367]                       if (has_future) {
[17:28:17.367]                         ns <- base::getNamespace("future")
[17:28:17.367]                         version <- ns[[".package"]][["version"]]
[17:28:17.367]                         if (is.null(version)) 
[17:28:17.367]                           version <- utils::packageVersion("future")
[17:28:17.367]                       }
[17:28:17.367]                       else {
[17:28:17.367]                         version <- NULL
[17:28:17.367]                       }
[17:28:17.367]                       if (!has_future || version < "1.8.0") {
[17:28:17.367]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.367]                           "", base::R.version$version.string), 
[17:28:17.367]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.367]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.367]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.367]                             "release", "version")], collapse = " "), 
[17:28:17.367]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.367]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.367]                           info)
[17:28:17.367]                         info <- base::paste(info, collapse = "; ")
[17:28:17.367]                         if (!has_future) {
[17:28:17.367]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.367]                             info)
[17:28:17.367]                         }
[17:28:17.367]                         else {
[17:28:17.367]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.367]                             info, version)
[17:28:17.367]                         }
[17:28:17.367]                         base::stop(msg)
[17:28:17.367]                       }
[17:28:17.367]                     })
[17:28:17.367]                   }
[17:28:17.367]                   ...future.strategy.old <- future::plan("list")
[17:28:17.367]                   options(future.plan = NULL)
[17:28:17.367]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.367]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.367]                 }
[17:28:17.367]                 ...future.workdir <- getwd()
[17:28:17.367]             }
[17:28:17.367]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.367]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.367]         }
[17:28:17.367]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.367]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.367]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.367]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.367]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.367]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.367]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.367]             base::names(...future.oldOptions))
[17:28:17.367]     }
[17:28:17.367]     if (FALSE) {
[17:28:17.367]     }
[17:28:17.367]     else {
[17:28:17.367]         if (TRUE) {
[17:28:17.367]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.367]                 open = "w")
[17:28:17.367]         }
[17:28:17.367]         else {
[17:28:17.367]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.367]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.367]         }
[17:28:17.367]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.367]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.367]             base::sink(type = "output", split = FALSE)
[17:28:17.367]             base::close(...future.stdout)
[17:28:17.367]         }, add = TRUE)
[17:28:17.367]     }
[17:28:17.367]     ...future.frame <- base::sys.nframe()
[17:28:17.367]     ...future.conditions <- base::list()
[17:28:17.367]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.367]     if (FALSE) {
[17:28:17.367]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.367]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.367]     }
[17:28:17.367]     ...future.result <- base::tryCatch({
[17:28:17.367]         base::withCallingHandlers({
[17:28:17.367]             ...future.value <- base::withVisible(base::local({
[17:28:17.367]                 sample(x, size = 1L)
[17:28:17.367]             }))
[17:28:17.367]             future::FutureResult(value = ...future.value$value, 
[17:28:17.367]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.367]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.367]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.367]                     ...future.globalenv.names))
[17:28:17.367]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.367]         }, condition = base::local({
[17:28:17.367]             c <- base::c
[17:28:17.367]             inherits <- base::inherits
[17:28:17.367]             invokeRestart <- base::invokeRestart
[17:28:17.367]             length <- base::length
[17:28:17.367]             list <- base::list
[17:28:17.367]             seq.int <- base::seq.int
[17:28:17.367]             signalCondition <- base::signalCondition
[17:28:17.367]             sys.calls <- base::sys.calls
[17:28:17.367]             `[[` <- base::`[[`
[17:28:17.367]             `+` <- base::`+`
[17:28:17.367]             `<<-` <- base::`<<-`
[17:28:17.367]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.367]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.367]                   3L)]
[17:28:17.367]             }
[17:28:17.367]             function(cond) {
[17:28:17.367]                 is_error <- inherits(cond, "error")
[17:28:17.367]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.367]                   NULL)
[17:28:17.367]                 if (is_error) {
[17:28:17.367]                   sessionInformation <- function() {
[17:28:17.367]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.367]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.367]                       search = base::search(), system = base::Sys.info())
[17:28:17.367]                   }
[17:28:17.367]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.367]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.367]                     cond$call), session = sessionInformation(), 
[17:28:17.367]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.367]                   signalCondition(cond)
[17:28:17.367]                 }
[17:28:17.367]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.367]                 "immediateCondition"))) {
[17:28:17.367]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.367]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.367]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.367]                   if (TRUE && !signal) {
[17:28:17.367]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.367]                     {
[17:28:17.367]                       inherits <- base::inherits
[17:28:17.367]                       invokeRestart <- base::invokeRestart
[17:28:17.367]                       is.null <- base::is.null
[17:28:17.367]                       muffled <- FALSE
[17:28:17.367]                       if (inherits(cond, "message")) {
[17:28:17.367]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.367]                         if (muffled) 
[17:28:17.367]                           invokeRestart("muffleMessage")
[17:28:17.367]                       }
[17:28:17.367]                       else if (inherits(cond, "warning")) {
[17:28:17.367]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.367]                         if (muffled) 
[17:28:17.367]                           invokeRestart("muffleWarning")
[17:28:17.367]                       }
[17:28:17.367]                       else if (inherits(cond, "condition")) {
[17:28:17.367]                         if (!is.null(pattern)) {
[17:28:17.367]                           computeRestarts <- base::computeRestarts
[17:28:17.367]                           grepl <- base::grepl
[17:28:17.367]                           restarts <- computeRestarts(cond)
[17:28:17.367]                           for (restart in restarts) {
[17:28:17.367]                             name <- restart$name
[17:28:17.367]                             if (is.null(name)) 
[17:28:17.367]                               next
[17:28:17.367]                             if (!grepl(pattern, name)) 
[17:28:17.367]                               next
[17:28:17.367]                             invokeRestart(restart)
[17:28:17.367]                             muffled <- TRUE
[17:28:17.367]                             break
[17:28:17.367]                           }
[17:28:17.367]                         }
[17:28:17.367]                       }
[17:28:17.367]                       invisible(muffled)
[17:28:17.367]                     }
[17:28:17.367]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.367]                   }
[17:28:17.367]                 }
[17:28:17.367]                 else {
[17:28:17.367]                   if (TRUE) {
[17:28:17.367]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.367]                     {
[17:28:17.367]                       inherits <- base::inherits
[17:28:17.367]                       invokeRestart <- base::invokeRestart
[17:28:17.367]                       is.null <- base::is.null
[17:28:17.367]                       muffled <- FALSE
[17:28:17.367]                       if (inherits(cond, "message")) {
[17:28:17.367]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.367]                         if (muffled) 
[17:28:17.367]                           invokeRestart("muffleMessage")
[17:28:17.367]                       }
[17:28:17.367]                       else if (inherits(cond, "warning")) {
[17:28:17.367]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.367]                         if (muffled) 
[17:28:17.367]                           invokeRestart("muffleWarning")
[17:28:17.367]                       }
[17:28:17.367]                       else if (inherits(cond, "condition")) {
[17:28:17.367]                         if (!is.null(pattern)) {
[17:28:17.367]                           computeRestarts <- base::computeRestarts
[17:28:17.367]                           grepl <- base::grepl
[17:28:17.367]                           restarts <- computeRestarts(cond)
[17:28:17.367]                           for (restart in restarts) {
[17:28:17.367]                             name <- restart$name
[17:28:17.367]                             if (is.null(name)) 
[17:28:17.367]                               next
[17:28:17.367]                             if (!grepl(pattern, name)) 
[17:28:17.367]                               next
[17:28:17.367]                             invokeRestart(restart)
[17:28:17.367]                             muffled <- TRUE
[17:28:17.367]                             break
[17:28:17.367]                           }
[17:28:17.367]                         }
[17:28:17.367]                       }
[17:28:17.367]                       invisible(muffled)
[17:28:17.367]                     }
[17:28:17.367]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.367]                   }
[17:28:17.367]                 }
[17:28:17.367]             }
[17:28:17.367]         }))
[17:28:17.367]     }, error = function(ex) {
[17:28:17.367]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.367]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.367]                 ...future.rng), started = ...future.startTime, 
[17:28:17.367]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.367]             version = "1.8"), class = "FutureResult")
[17:28:17.367]     }, finally = {
[17:28:17.367]         if (!identical(...future.workdir, getwd())) 
[17:28:17.367]             setwd(...future.workdir)
[17:28:17.367]         {
[17:28:17.367]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.367]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.367]             }
[17:28:17.367]             base::options(...future.oldOptions)
[17:28:17.367]             if (.Platform$OS.type == "windows") {
[17:28:17.367]                 old_names <- names(...future.oldEnvVars)
[17:28:17.367]                 envs <- base::Sys.getenv()
[17:28:17.367]                 names <- names(envs)
[17:28:17.367]                 common <- intersect(names, old_names)
[17:28:17.367]                 added <- setdiff(names, old_names)
[17:28:17.367]                 removed <- setdiff(old_names, names)
[17:28:17.367]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.367]                   envs[common]]
[17:28:17.367]                 NAMES <- toupper(changed)
[17:28:17.367]                 args <- list()
[17:28:17.367]                 for (kk in seq_along(NAMES)) {
[17:28:17.367]                   name <- changed[[kk]]
[17:28:17.367]                   NAME <- NAMES[[kk]]
[17:28:17.367]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.367]                     next
[17:28:17.367]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.367]                 }
[17:28:17.367]                 NAMES <- toupper(added)
[17:28:17.367]                 for (kk in seq_along(NAMES)) {
[17:28:17.367]                   name <- added[[kk]]
[17:28:17.367]                   NAME <- NAMES[[kk]]
[17:28:17.367]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.367]                     next
[17:28:17.367]                   args[[name]] <- ""
[17:28:17.367]                 }
[17:28:17.367]                 NAMES <- toupper(removed)
[17:28:17.367]                 for (kk in seq_along(NAMES)) {
[17:28:17.367]                   name <- removed[[kk]]
[17:28:17.367]                   NAME <- NAMES[[kk]]
[17:28:17.367]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.367]                     next
[17:28:17.367]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.367]                 }
[17:28:17.367]                 if (length(args) > 0) 
[17:28:17.367]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.367]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.367]             }
[17:28:17.367]             else {
[17:28:17.367]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.367]             }
[17:28:17.367]             {
[17:28:17.367]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.367]                   0L) {
[17:28:17.367]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.367]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.367]                   base::options(opts)
[17:28:17.367]                 }
[17:28:17.367]                 {
[17:28:17.367]                   {
[17:28:17.367]                     base::assign(".Random.seed", c(10407L, -272798089L, 
[17:28:17.367]                     -315111812L, 149633403L, -1555199413L, 1104122703L, 
[17:28:17.367]                     -1159683708L), envir = base::globalenv(), 
[17:28:17.367]                       inherits = FALSE)
[17:28:17.367]                     NULL
[17:28:17.367]                   }
[17:28:17.367]                   options(future.plan = NULL)
[17:28:17.367]                   if (is.na(NA_character_)) 
[17:28:17.367]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.367]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.367]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.367]                     .init = FALSE)
[17:28:17.367]                 }
[17:28:17.367]             }
[17:28:17.367]         }
[17:28:17.367]     })
[17:28:17.367]     if (TRUE) {
[17:28:17.367]         base::sink(type = "output", split = FALSE)
[17:28:17.367]         if (TRUE) {
[17:28:17.367]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.367]         }
[17:28:17.367]         else {
[17:28:17.367]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.367]         }
[17:28:17.367]         base::close(...future.stdout)
[17:28:17.367]         ...future.stdout <- NULL
[17:28:17.367]     }
[17:28:17.367]     ...future.result$conditions <- ...future.conditions
[17:28:17.367]     ...future.result$finished <- base::Sys.time()
[17:28:17.367]     ...future.result
[17:28:17.367] }
[17:28:17.371] assign_globals() ...
[17:28:17.371] List of 1
[17:28:17.371]  $ x: int [1:4] 0 1 2 3
[17:28:17.371]  - attr(*, "where")=List of 1
[17:28:17.371]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.371]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.371]  - attr(*, "resolved")= logi FALSE
[17:28:17.371]  - attr(*, "total_size")= num 64
[17:28:17.371]  - attr(*, "already-done")= logi TRUE
[17:28:17.374] - copied 'x' to environment
[17:28:17.374] assign_globals() ... done
[17:28:17.375] plan(): Setting new future strategy stack:
[17:28:17.375] List of future strategies:
[17:28:17.375] 1. sequential:
[17:28:17.375]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.375]    - tweaked: FALSE
[17:28:17.375]    - call: NULL
[17:28:17.375] plan(): nbrOfWorkers() = 1
[17:28:17.377] plan(): Setting new future strategy stack:
[17:28:17.377] List of future strategies:
[17:28:17.377] 1. sequential:
[17:28:17.377]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.377]    - tweaked: FALSE
[17:28:17.377]    - call: plan(strategy)
[17:28:17.377] plan(): nbrOfWorkers() = 1
[17:28:17.378] SequentialFuture started (and completed)
[17:28:17.378] - Launch lazy future ... done
[17:28:17.378] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-544267'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x0000026673a19b50
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.380] getGlobalsAndPackages() ...
[17:28:17.381] Searching for globals...
[17:28:17.382] - globals found: [3] '{', 'sample', 'x'
[17:28:17.382] Searching for globals ... DONE
[17:28:17.382] Resolving globals: FALSE
[17:28:17.383] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.383] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.383] - globals: [1] 'x'
[17:28:17.383] 
[17:28:17.384] getGlobalsAndPackages() ... DONE
[17:28:17.384] run() for 'Future' ...
[17:28:17.384] - state: 'created'
[17:28:17.384] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.385] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.385] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.385]   - Field: 'label'
[17:28:17.385]   - Field: 'local'
[17:28:17.385]   - Field: 'owner'
[17:28:17.385]   - Field: 'envir'
[17:28:17.386]   - Field: 'packages'
[17:28:17.386]   - Field: 'gc'
[17:28:17.386]   - Field: 'conditions'
[17:28:17.386]   - Field: 'expr'
[17:28:17.386]   - Field: 'uuid'
[17:28:17.387]   - Field: 'seed'
[17:28:17.387]   - Field: 'version'
[17:28:17.387]   - Field: 'result'
[17:28:17.387]   - Field: 'asynchronous'
[17:28:17.387]   - Field: 'calls'
[17:28:17.387]   - Field: 'globals'
[17:28:17.388]   - Field: 'stdout'
[17:28:17.388]   - Field: 'earlySignal'
[17:28:17.388]   - Field: 'lazy'
[17:28:17.388]   - Field: 'state'
[17:28:17.388] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.388] - Launch lazy future ...
[17:28:17.389] Packages needed by the future expression (n = 0): <none>
[17:28:17.389] Packages needed by future strategies (n = 0): <none>
[17:28:17.389] {
[17:28:17.389]     {
[17:28:17.389]         {
[17:28:17.389]             ...future.startTime <- base::Sys.time()
[17:28:17.389]             {
[17:28:17.389]                 {
[17:28:17.389]                   {
[17:28:17.389]                     base::local({
[17:28:17.389]                       has_future <- base::requireNamespace("future", 
[17:28:17.389]                         quietly = TRUE)
[17:28:17.389]                       if (has_future) {
[17:28:17.389]                         ns <- base::getNamespace("future")
[17:28:17.389]                         version <- ns[[".package"]][["version"]]
[17:28:17.389]                         if (is.null(version)) 
[17:28:17.389]                           version <- utils::packageVersion("future")
[17:28:17.389]                       }
[17:28:17.389]                       else {
[17:28:17.389]                         version <- NULL
[17:28:17.389]                       }
[17:28:17.389]                       if (!has_future || version < "1.8.0") {
[17:28:17.389]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.389]                           "", base::R.version$version.string), 
[17:28:17.389]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.389]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.389]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.389]                             "release", "version")], collapse = " "), 
[17:28:17.389]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.389]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.389]                           info)
[17:28:17.389]                         info <- base::paste(info, collapse = "; ")
[17:28:17.389]                         if (!has_future) {
[17:28:17.389]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.389]                             info)
[17:28:17.389]                         }
[17:28:17.389]                         else {
[17:28:17.389]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.389]                             info, version)
[17:28:17.389]                         }
[17:28:17.389]                         base::stop(msg)
[17:28:17.389]                       }
[17:28:17.389]                     })
[17:28:17.389]                   }
[17:28:17.389]                   ...future.strategy.old <- future::plan("list")
[17:28:17.389]                   options(future.plan = NULL)
[17:28:17.389]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.389]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.389]                 }
[17:28:17.389]                 ...future.workdir <- getwd()
[17:28:17.389]             }
[17:28:17.389]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.389]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.389]         }
[17:28:17.389]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.389]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.389]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.389]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.389]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.389]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.389]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.389]             base::names(...future.oldOptions))
[17:28:17.389]     }
[17:28:17.389]     if (FALSE) {
[17:28:17.389]     }
[17:28:17.389]     else {
[17:28:17.389]         if (TRUE) {
[17:28:17.389]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.389]                 open = "w")
[17:28:17.389]         }
[17:28:17.389]         else {
[17:28:17.389]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.389]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.389]         }
[17:28:17.389]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.389]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.389]             base::sink(type = "output", split = FALSE)
[17:28:17.389]             base::close(...future.stdout)
[17:28:17.389]         }, add = TRUE)
[17:28:17.389]     }
[17:28:17.389]     ...future.frame <- base::sys.nframe()
[17:28:17.389]     ...future.conditions <- base::list()
[17:28:17.389]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.389]     if (FALSE) {
[17:28:17.389]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.389]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.389]     }
[17:28:17.389]     ...future.result <- base::tryCatch({
[17:28:17.389]         base::withCallingHandlers({
[17:28:17.389]             ...future.value <- base::withVisible(base::local({
[17:28:17.389]                 sample(x, size = 1L)
[17:28:17.389]             }))
[17:28:17.389]             future::FutureResult(value = ...future.value$value, 
[17:28:17.389]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.389]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.389]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.389]                     ...future.globalenv.names))
[17:28:17.389]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.389]         }, condition = base::local({
[17:28:17.389]             c <- base::c
[17:28:17.389]             inherits <- base::inherits
[17:28:17.389]             invokeRestart <- base::invokeRestart
[17:28:17.389]             length <- base::length
[17:28:17.389]             list <- base::list
[17:28:17.389]             seq.int <- base::seq.int
[17:28:17.389]             signalCondition <- base::signalCondition
[17:28:17.389]             sys.calls <- base::sys.calls
[17:28:17.389]             `[[` <- base::`[[`
[17:28:17.389]             `+` <- base::`+`
[17:28:17.389]             `<<-` <- base::`<<-`
[17:28:17.389]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.389]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.389]                   3L)]
[17:28:17.389]             }
[17:28:17.389]             function(cond) {
[17:28:17.389]                 is_error <- inherits(cond, "error")
[17:28:17.389]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.389]                   NULL)
[17:28:17.389]                 if (is_error) {
[17:28:17.389]                   sessionInformation <- function() {
[17:28:17.389]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.389]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.389]                       search = base::search(), system = base::Sys.info())
[17:28:17.389]                   }
[17:28:17.389]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.389]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.389]                     cond$call), session = sessionInformation(), 
[17:28:17.389]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.389]                   signalCondition(cond)
[17:28:17.389]                 }
[17:28:17.389]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.389]                 "immediateCondition"))) {
[17:28:17.389]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.389]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.389]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.389]                   if (TRUE && !signal) {
[17:28:17.389]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.389]                     {
[17:28:17.389]                       inherits <- base::inherits
[17:28:17.389]                       invokeRestart <- base::invokeRestart
[17:28:17.389]                       is.null <- base::is.null
[17:28:17.389]                       muffled <- FALSE
[17:28:17.389]                       if (inherits(cond, "message")) {
[17:28:17.389]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.389]                         if (muffled) 
[17:28:17.389]                           invokeRestart("muffleMessage")
[17:28:17.389]                       }
[17:28:17.389]                       else if (inherits(cond, "warning")) {
[17:28:17.389]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.389]                         if (muffled) 
[17:28:17.389]                           invokeRestart("muffleWarning")
[17:28:17.389]                       }
[17:28:17.389]                       else if (inherits(cond, "condition")) {
[17:28:17.389]                         if (!is.null(pattern)) {
[17:28:17.389]                           computeRestarts <- base::computeRestarts
[17:28:17.389]                           grepl <- base::grepl
[17:28:17.389]                           restarts <- computeRestarts(cond)
[17:28:17.389]                           for (restart in restarts) {
[17:28:17.389]                             name <- restart$name
[17:28:17.389]                             if (is.null(name)) 
[17:28:17.389]                               next
[17:28:17.389]                             if (!grepl(pattern, name)) 
[17:28:17.389]                               next
[17:28:17.389]                             invokeRestart(restart)
[17:28:17.389]                             muffled <- TRUE
[17:28:17.389]                             break
[17:28:17.389]                           }
[17:28:17.389]                         }
[17:28:17.389]                       }
[17:28:17.389]                       invisible(muffled)
[17:28:17.389]                     }
[17:28:17.389]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.389]                   }
[17:28:17.389]                 }
[17:28:17.389]                 else {
[17:28:17.389]                   if (TRUE) {
[17:28:17.389]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.389]                     {
[17:28:17.389]                       inherits <- base::inherits
[17:28:17.389]                       invokeRestart <- base::invokeRestart
[17:28:17.389]                       is.null <- base::is.null
[17:28:17.389]                       muffled <- FALSE
[17:28:17.389]                       if (inherits(cond, "message")) {
[17:28:17.389]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.389]                         if (muffled) 
[17:28:17.389]                           invokeRestart("muffleMessage")
[17:28:17.389]                       }
[17:28:17.389]                       else if (inherits(cond, "warning")) {
[17:28:17.389]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.389]                         if (muffled) 
[17:28:17.389]                           invokeRestart("muffleWarning")
[17:28:17.389]                       }
[17:28:17.389]                       else if (inherits(cond, "condition")) {
[17:28:17.389]                         if (!is.null(pattern)) {
[17:28:17.389]                           computeRestarts <- base::computeRestarts
[17:28:17.389]                           grepl <- base::grepl
[17:28:17.389]                           restarts <- computeRestarts(cond)
[17:28:17.389]                           for (restart in restarts) {
[17:28:17.389]                             name <- restart$name
[17:28:17.389]                             if (is.null(name)) 
[17:28:17.389]                               next
[17:28:17.389]                             if (!grepl(pattern, name)) 
[17:28:17.389]                               next
[17:28:17.389]                             invokeRestart(restart)
[17:28:17.389]                             muffled <- TRUE
[17:28:17.389]                             break
[17:28:17.389]                           }
[17:28:17.389]                         }
[17:28:17.389]                       }
[17:28:17.389]                       invisible(muffled)
[17:28:17.389]                     }
[17:28:17.389]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.389]                   }
[17:28:17.389]                 }
[17:28:17.389]             }
[17:28:17.389]         }))
[17:28:17.389]     }, error = function(ex) {
[17:28:17.389]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.389]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.389]                 ...future.rng), started = ...future.startTime, 
[17:28:17.389]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.389]             version = "1.8"), class = "FutureResult")
[17:28:17.389]     }, finally = {
[17:28:17.389]         if (!identical(...future.workdir, getwd())) 
[17:28:17.389]             setwd(...future.workdir)
[17:28:17.389]         {
[17:28:17.389]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.389]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.389]             }
[17:28:17.389]             base::options(...future.oldOptions)
[17:28:17.389]             if (.Platform$OS.type == "windows") {
[17:28:17.389]                 old_names <- names(...future.oldEnvVars)
[17:28:17.389]                 envs <- base::Sys.getenv()
[17:28:17.389]                 names <- names(envs)
[17:28:17.389]                 common <- intersect(names, old_names)
[17:28:17.389]                 added <- setdiff(names, old_names)
[17:28:17.389]                 removed <- setdiff(old_names, names)
[17:28:17.389]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.389]                   envs[common]]
[17:28:17.389]                 NAMES <- toupper(changed)
[17:28:17.389]                 args <- list()
[17:28:17.389]                 for (kk in seq_along(NAMES)) {
[17:28:17.389]                   name <- changed[[kk]]
[17:28:17.389]                   NAME <- NAMES[[kk]]
[17:28:17.389]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.389]                     next
[17:28:17.389]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.389]                 }
[17:28:17.389]                 NAMES <- toupper(added)
[17:28:17.389]                 for (kk in seq_along(NAMES)) {
[17:28:17.389]                   name <- added[[kk]]
[17:28:17.389]                   NAME <- NAMES[[kk]]
[17:28:17.389]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.389]                     next
[17:28:17.389]                   args[[name]] <- ""
[17:28:17.389]                 }
[17:28:17.389]                 NAMES <- toupper(removed)
[17:28:17.389]                 for (kk in seq_along(NAMES)) {
[17:28:17.389]                   name <- removed[[kk]]
[17:28:17.389]                   NAME <- NAMES[[kk]]
[17:28:17.389]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.389]                     next
[17:28:17.389]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.389]                 }
[17:28:17.389]                 if (length(args) > 0) 
[17:28:17.389]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.389]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.389]             }
[17:28:17.389]             else {
[17:28:17.389]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.389]             }
[17:28:17.389]             {
[17:28:17.389]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.389]                   0L) {
[17:28:17.389]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.389]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.389]                   base::options(opts)
[17:28:17.389]                 }
[17:28:17.389]                 {
[17:28:17.389]                   {
[17:28:17.389]                     base::assign(".Random.seed", c(10407L, 149633403L, 
[17:28:17.389]                     -1673542288L, -576396632L, -1159683708L, 
[17:28:17.389]                     -1814401748L, -1322062327L), envir = base::globalenv(), 
[17:28:17.389]                       inherits = FALSE)
[17:28:17.389]                     NULL
[17:28:17.389]                   }
[17:28:17.389]                   options(future.plan = NULL)
[17:28:17.389]                   if (is.na(NA_character_)) 
[17:28:17.389]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.389]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.389]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.389]                     .init = FALSE)
[17:28:17.389]                 }
[17:28:17.389]             }
[17:28:17.389]         }
[17:28:17.389]     })
[17:28:17.389]     if (TRUE) {
[17:28:17.389]         base::sink(type = "output", split = FALSE)
[17:28:17.389]         if (TRUE) {
[17:28:17.389]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.389]         }
[17:28:17.389]         else {
[17:28:17.389]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.389]         }
[17:28:17.389]         base::close(...future.stdout)
[17:28:17.389]         ...future.stdout <- NULL
[17:28:17.389]     }
[17:28:17.389]     ...future.result$conditions <- ...future.conditions
[17:28:17.389]     ...future.result$finished <- base::Sys.time()
[17:28:17.389]     ...future.result
[17:28:17.389] }
[17:28:17.393] assign_globals() ...
[17:28:17.393] List of 1
[17:28:17.393]  $ x: int [1:4] 0 1 2 3
[17:28:17.393]  - attr(*, "where")=List of 1
[17:28:17.393]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.393]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.393]  - attr(*, "resolved")= logi FALSE
[17:28:17.393]  - attr(*, "total_size")= num 64
[17:28:17.393]  - attr(*, "already-done")= logi TRUE
[17:28:17.396] - copied 'x' to environment
[17:28:17.396] assign_globals() ... done
[17:28:17.397] plan(): Setting new future strategy stack:
[17:28:17.397] List of future strategies:
[17:28:17.397] 1. sequential:
[17:28:17.397]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.397]    - tweaked: FALSE
[17:28:17.397]    - call: NULL
[17:28:17.397] plan(): nbrOfWorkers() = 1
[17:28:17.398] plan(): Setting new future strategy stack:
[17:28:17.399] List of future strategies:
[17:28:17.399] 1. sequential:
[17:28:17.399]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.399]    - tweaked: FALSE
[17:28:17.399]    - call: plan(strategy)
[17:28:17.399] plan(): nbrOfWorkers() = 1
[17:28:17.400] SequentialFuture started (and completed)
[17:28:17.400] - Launch lazy future ... done
[17:28:17.400] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-339058'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x0000026673a19b50
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.401] getGlobalsAndPackages() ...
[17:28:17.401] Searching for globals...
[17:28:17.402] - globals found: [3] '{', 'sample', 'x'
[17:28:17.402] Searching for globals ... DONE
[17:28:17.403] Resolving globals: FALSE
[17:28:17.403] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.403] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.404] - globals: [1] 'x'
[17:28:17.404] 
[17:28:17.404] getGlobalsAndPackages() ... DONE
[17:28:17.404] run() for 'Future' ...
[17:28:17.405] - state: 'created'
[17:28:17.405] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.405] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.405] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.405]   - Field: 'label'
[17:28:17.406]   - Field: 'local'
[17:28:17.406]   - Field: 'owner'
[17:28:17.406]   - Field: 'envir'
[17:28:17.406]   - Field: 'packages'
[17:28:17.406]   - Field: 'gc'
[17:28:17.407]   - Field: 'conditions'
[17:28:17.407]   - Field: 'expr'
[17:28:17.407]   - Field: 'uuid'
[17:28:17.407]   - Field: 'seed'
[17:28:17.407]   - Field: 'version'
[17:28:17.407]   - Field: 'result'
[17:28:17.408]   - Field: 'asynchronous'
[17:28:17.408]   - Field: 'calls'
[17:28:17.408]   - Field: 'globals'
[17:28:17.408]   - Field: 'stdout'
[17:28:17.408]   - Field: 'earlySignal'
[17:28:17.408]   - Field: 'lazy'
[17:28:17.409]   - Field: 'state'
[17:28:17.409] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.409] - Launch lazy future ...
[17:28:17.409] Packages needed by the future expression (n = 0): <none>
[17:28:17.409] Packages needed by future strategies (n = 0): <none>
[17:28:17.410] {
[17:28:17.410]     {
[17:28:17.410]         {
[17:28:17.410]             ...future.startTime <- base::Sys.time()
[17:28:17.410]             {
[17:28:17.410]                 {
[17:28:17.410]                   {
[17:28:17.410]                     base::local({
[17:28:17.410]                       has_future <- base::requireNamespace("future", 
[17:28:17.410]                         quietly = TRUE)
[17:28:17.410]                       if (has_future) {
[17:28:17.410]                         ns <- base::getNamespace("future")
[17:28:17.410]                         version <- ns[[".package"]][["version"]]
[17:28:17.410]                         if (is.null(version)) 
[17:28:17.410]                           version <- utils::packageVersion("future")
[17:28:17.410]                       }
[17:28:17.410]                       else {
[17:28:17.410]                         version <- NULL
[17:28:17.410]                       }
[17:28:17.410]                       if (!has_future || version < "1.8.0") {
[17:28:17.410]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.410]                           "", base::R.version$version.string), 
[17:28:17.410]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.410]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.410]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.410]                             "release", "version")], collapse = " "), 
[17:28:17.410]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.410]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.410]                           info)
[17:28:17.410]                         info <- base::paste(info, collapse = "; ")
[17:28:17.410]                         if (!has_future) {
[17:28:17.410]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.410]                             info)
[17:28:17.410]                         }
[17:28:17.410]                         else {
[17:28:17.410]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.410]                             info, version)
[17:28:17.410]                         }
[17:28:17.410]                         base::stop(msg)
[17:28:17.410]                       }
[17:28:17.410]                     })
[17:28:17.410]                   }
[17:28:17.410]                   ...future.strategy.old <- future::plan("list")
[17:28:17.410]                   options(future.plan = NULL)
[17:28:17.410]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.410]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.410]                 }
[17:28:17.410]                 ...future.workdir <- getwd()
[17:28:17.410]             }
[17:28:17.410]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.410]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.410]         }
[17:28:17.410]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.410]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.410]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.410]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.410]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.410]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.410]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.410]             base::names(...future.oldOptions))
[17:28:17.410]     }
[17:28:17.410]     if (FALSE) {
[17:28:17.410]     }
[17:28:17.410]     else {
[17:28:17.410]         if (TRUE) {
[17:28:17.410]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.410]                 open = "w")
[17:28:17.410]         }
[17:28:17.410]         else {
[17:28:17.410]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.410]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.410]         }
[17:28:17.410]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.410]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.410]             base::sink(type = "output", split = FALSE)
[17:28:17.410]             base::close(...future.stdout)
[17:28:17.410]         }, add = TRUE)
[17:28:17.410]     }
[17:28:17.410]     ...future.frame <- base::sys.nframe()
[17:28:17.410]     ...future.conditions <- base::list()
[17:28:17.410]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.410]     if (FALSE) {
[17:28:17.410]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.410]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.410]     }
[17:28:17.410]     ...future.result <- base::tryCatch({
[17:28:17.410]         base::withCallingHandlers({
[17:28:17.410]             ...future.value <- base::withVisible(base::local({
[17:28:17.410]                 sample(x, size = 1L)
[17:28:17.410]             }))
[17:28:17.410]             future::FutureResult(value = ...future.value$value, 
[17:28:17.410]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.410]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.410]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.410]                     ...future.globalenv.names))
[17:28:17.410]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.410]         }, condition = base::local({
[17:28:17.410]             c <- base::c
[17:28:17.410]             inherits <- base::inherits
[17:28:17.410]             invokeRestart <- base::invokeRestart
[17:28:17.410]             length <- base::length
[17:28:17.410]             list <- base::list
[17:28:17.410]             seq.int <- base::seq.int
[17:28:17.410]             signalCondition <- base::signalCondition
[17:28:17.410]             sys.calls <- base::sys.calls
[17:28:17.410]             `[[` <- base::`[[`
[17:28:17.410]             `+` <- base::`+`
[17:28:17.410]             `<<-` <- base::`<<-`
[17:28:17.410]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.410]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.410]                   3L)]
[17:28:17.410]             }
[17:28:17.410]             function(cond) {
[17:28:17.410]                 is_error <- inherits(cond, "error")
[17:28:17.410]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.410]                   NULL)
[17:28:17.410]                 if (is_error) {
[17:28:17.410]                   sessionInformation <- function() {
[17:28:17.410]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.410]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.410]                       search = base::search(), system = base::Sys.info())
[17:28:17.410]                   }
[17:28:17.410]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.410]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.410]                     cond$call), session = sessionInformation(), 
[17:28:17.410]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.410]                   signalCondition(cond)
[17:28:17.410]                 }
[17:28:17.410]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.410]                 "immediateCondition"))) {
[17:28:17.410]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.410]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.410]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.410]                   if (TRUE && !signal) {
[17:28:17.410]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.410]                     {
[17:28:17.410]                       inherits <- base::inherits
[17:28:17.410]                       invokeRestart <- base::invokeRestart
[17:28:17.410]                       is.null <- base::is.null
[17:28:17.410]                       muffled <- FALSE
[17:28:17.410]                       if (inherits(cond, "message")) {
[17:28:17.410]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.410]                         if (muffled) 
[17:28:17.410]                           invokeRestart("muffleMessage")
[17:28:17.410]                       }
[17:28:17.410]                       else if (inherits(cond, "warning")) {
[17:28:17.410]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.410]                         if (muffled) 
[17:28:17.410]                           invokeRestart("muffleWarning")
[17:28:17.410]                       }
[17:28:17.410]                       else if (inherits(cond, "condition")) {
[17:28:17.410]                         if (!is.null(pattern)) {
[17:28:17.410]                           computeRestarts <- base::computeRestarts
[17:28:17.410]                           grepl <- base::grepl
[17:28:17.410]                           restarts <- computeRestarts(cond)
[17:28:17.410]                           for (restart in restarts) {
[17:28:17.410]                             name <- restart$name
[17:28:17.410]                             if (is.null(name)) 
[17:28:17.410]                               next
[17:28:17.410]                             if (!grepl(pattern, name)) 
[17:28:17.410]                               next
[17:28:17.410]                             invokeRestart(restart)
[17:28:17.410]                             muffled <- TRUE
[17:28:17.410]                             break
[17:28:17.410]                           }
[17:28:17.410]                         }
[17:28:17.410]                       }
[17:28:17.410]                       invisible(muffled)
[17:28:17.410]                     }
[17:28:17.410]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.410]                   }
[17:28:17.410]                 }
[17:28:17.410]                 else {
[17:28:17.410]                   if (TRUE) {
[17:28:17.410]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.410]                     {
[17:28:17.410]                       inherits <- base::inherits
[17:28:17.410]                       invokeRestart <- base::invokeRestart
[17:28:17.410]                       is.null <- base::is.null
[17:28:17.410]                       muffled <- FALSE
[17:28:17.410]                       if (inherits(cond, "message")) {
[17:28:17.410]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.410]                         if (muffled) 
[17:28:17.410]                           invokeRestart("muffleMessage")
[17:28:17.410]                       }
[17:28:17.410]                       else if (inherits(cond, "warning")) {
[17:28:17.410]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.410]                         if (muffled) 
[17:28:17.410]                           invokeRestart("muffleWarning")
[17:28:17.410]                       }
[17:28:17.410]                       else if (inherits(cond, "condition")) {
[17:28:17.410]                         if (!is.null(pattern)) {
[17:28:17.410]                           computeRestarts <- base::computeRestarts
[17:28:17.410]                           grepl <- base::grepl
[17:28:17.410]                           restarts <- computeRestarts(cond)
[17:28:17.410]                           for (restart in restarts) {
[17:28:17.410]                             name <- restart$name
[17:28:17.410]                             if (is.null(name)) 
[17:28:17.410]                               next
[17:28:17.410]                             if (!grepl(pattern, name)) 
[17:28:17.410]                               next
[17:28:17.410]                             invokeRestart(restart)
[17:28:17.410]                             muffled <- TRUE
[17:28:17.410]                             break
[17:28:17.410]                           }
[17:28:17.410]                         }
[17:28:17.410]                       }
[17:28:17.410]                       invisible(muffled)
[17:28:17.410]                     }
[17:28:17.410]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.410]                   }
[17:28:17.410]                 }
[17:28:17.410]             }
[17:28:17.410]         }))
[17:28:17.410]     }, error = function(ex) {
[17:28:17.410]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.410]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.410]                 ...future.rng), started = ...future.startTime, 
[17:28:17.410]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.410]             version = "1.8"), class = "FutureResult")
[17:28:17.410]     }, finally = {
[17:28:17.410]         if (!identical(...future.workdir, getwd())) 
[17:28:17.410]             setwd(...future.workdir)
[17:28:17.410]         {
[17:28:17.410]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.410]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.410]             }
[17:28:17.410]             base::options(...future.oldOptions)
[17:28:17.410]             if (.Platform$OS.type == "windows") {
[17:28:17.410]                 old_names <- names(...future.oldEnvVars)
[17:28:17.410]                 envs <- base::Sys.getenv()
[17:28:17.410]                 names <- names(envs)
[17:28:17.410]                 common <- intersect(names, old_names)
[17:28:17.410]                 added <- setdiff(names, old_names)
[17:28:17.410]                 removed <- setdiff(old_names, names)
[17:28:17.410]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.410]                   envs[common]]
[17:28:17.410]                 NAMES <- toupper(changed)
[17:28:17.410]                 args <- list()
[17:28:17.410]                 for (kk in seq_along(NAMES)) {
[17:28:17.410]                   name <- changed[[kk]]
[17:28:17.410]                   NAME <- NAMES[[kk]]
[17:28:17.410]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.410]                     next
[17:28:17.410]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.410]                 }
[17:28:17.410]                 NAMES <- toupper(added)
[17:28:17.410]                 for (kk in seq_along(NAMES)) {
[17:28:17.410]                   name <- added[[kk]]
[17:28:17.410]                   NAME <- NAMES[[kk]]
[17:28:17.410]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.410]                     next
[17:28:17.410]                   args[[name]] <- ""
[17:28:17.410]                 }
[17:28:17.410]                 NAMES <- toupper(removed)
[17:28:17.410]                 for (kk in seq_along(NAMES)) {
[17:28:17.410]                   name <- removed[[kk]]
[17:28:17.410]                   NAME <- NAMES[[kk]]
[17:28:17.410]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.410]                     next
[17:28:17.410]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.410]                 }
[17:28:17.410]                 if (length(args) > 0) 
[17:28:17.410]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.410]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.410]             }
[17:28:17.410]             else {
[17:28:17.410]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.410]             }
[17:28:17.410]             {
[17:28:17.410]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.410]                   0L) {
[17:28:17.410]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.410]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.410]                   base::options(opts)
[17:28:17.410]                 }
[17:28:17.410]                 {
[17:28:17.410]                   {
[17:28:17.410]                     base::assign(".Random.seed", c(10407L, -576396632L, 
[17:28:17.410]                     1024199107L, 1713854453L, -1322062327L, 2062659684L, 
[17:28:17.410]                     131382765L), envir = base::globalenv(), inherits = FALSE)
[17:28:17.410]                     NULL
[17:28:17.410]                   }
[17:28:17.410]                   options(future.plan = NULL)
[17:28:17.410]                   if (is.na(NA_character_)) 
[17:28:17.410]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.410]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.410]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.410]                     .init = FALSE)
[17:28:17.410]                 }
[17:28:17.410]             }
[17:28:17.410]         }
[17:28:17.410]     })
[17:28:17.410]     if (TRUE) {
[17:28:17.410]         base::sink(type = "output", split = FALSE)
[17:28:17.410]         if (TRUE) {
[17:28:17.410]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.410]         }
[17:28:17.410]         else {
[17:28:17.410]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.410]         }
[17:28:17.410]         base::close(...future.stdout)
[17:28:17.410]         ...future.stdout <- NULL
[17:28:17.410]     }
[17:28:17.410]     ...future.result$conditions <- ...future.conditions
[17:28:17.410]     ...future.result$finished <- base::Sys.time()
[17:28:17.410]     ...future.result
[17:28:17.410] }
[17:28:17.415] assign_globals() ...
[17:28:17.415] List of 1
[17:28:17.415]  $ x: int [1:4] 0 1 2 3
[17:28:17.415]  - attr(*, "where")=List of 1
[17:28:17.415]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.415]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.415]  - attr(*, "resolved")= logi FALSE
[17:28:17.415]  - attr(*, "total_size")= num 64
[17:28:17.415]  - attr(*, "already-done")= logi TRUE
[17:28:17.418] - copied 'x' to environment
[17:28:17.418] assign_globals() ... done
[17:28:17.418] plan(): Setting new future strategy stack:
[17:28:17.419] List of future strategies:
[17:28:17.419] 1. sequential:
[17:28:17.419]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.419]    - tweaked: FALSE
[17:28:17.419]    - call: NULL
[17:28:17.419] plan(): nbrOfWorkers() = 1
[17:28:17.420] plan(): Setting new future strategy stack:
[17:28:17.420] List of future strategies:
[17:28:17.420] 1. sequential:
[17:28:17.420]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.420]    - tweaked: FALSE
[17:28:17.420]    - call: plan(strategy)
[17:28:17.421] plan(): nbrOfWorkers() = 1
[17:28:17.421] SequentialFuture started (and completed)
[17:28:17.421] - Launch lazy future ... done
[17:28:17.422] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-679507'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x0000026673a19b50
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.423] resolve() on list ...
[17:28:17.423]  recursive: 0
[17:28:17.423]  length: 4
[17:28:17.423] 
[17:28:17.423] resolved() for 'SequentialFuture' ...
[17:28:17.423] - state: 'finished'
[17:28:17.424] - run: TRUE
[17:28:17.424] - result: 'FutureResult'
[17:28:17.424] resolved() for 'SequentialFuture' ... done
[17:28:17.424] Future #1
[17:28:17.424] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:28:17.425] - nx: 4
[17:28:17.425] - relay: TRUE
[17:28:17.425] - stdout: TRUE
[17:28:17.425] - signal: TRUE
[17:28:17.425] - resignal: FALSE
[17:28:17.425] - force: TRUE
[17:28:17.426] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.426] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.426]  - until=1
[17:28:17.426]  - relaying element #1
[17:28:17.426] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.426] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.427] signalConditionsASAP(SequentialFuture, pos=1) ... done
[17:28:17.427]  length: 3 (resolved future 1)
[17:28:17.427] resolved() for 'SequentialFuture' ...
[17:28:17.427] - state: 'finished'
[17:28:17.427] - run: TRUE
[17:28:17.428] - result: 'FutureResult'
[17:28:17.428] resolved() for 'SequentialFuture' ... done
[17:28:17.428] Future #2
[17:28:17.428] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:28:17.428] - nx: 4
[17:28:17.428] - relay: TRUE
[17:28:17.429] - stdout: TRUE
[17:28:17.429] - signal: TRUE
[17:28:17.429] - resignal: FALSE
[17:28:17.429] - force: TRUE
[17:28:17.429] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.429] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.430]  - until=2
[17:28:17.430]  - relaying element #2
[17:28:17.430] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.430] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.430] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:28:17.430]  length: 2 (resolved future 2)
[17:28:17.431] resolved() for 'SequentialFuture' ...
[17:28:17.431] - state: 'finished'
[17:28:17.431] - run: TRUE
[17:28:17.431] - result: 'FutureResult'
[17:28:17.431] resolved() for 'SequentialFuture' ... done
[17:28:17.432] Future #3
[17:28:17.432] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:28:17.432] - nx: 4
[17:28:17.432] - relay: TRUE
[17:28:17.432] - stdout: TRUE
[17:28:17.432] - signal: TRUE
[17:28:17.433] - resignal: FALSE
[17:28:17.433] - force: TRUE
[17:28:17.433] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.433] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.433]  - until=3
[17:28:17.433]  - relaying element #3
[17:28:17.434] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.434] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.434] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:28:17.434]  length: 1 (resolved future 3)
[17:28:17.434] resolved() for 'SequentialFuture' ...
[17:28:17.435] - state: 'finished'
[17:28:17.435] - run: TRUE
[17:28:17.435] - result: 'FutureResult'
[17:28:17.435] resolved() for 'SequentialFuture' ... done
[17:28:17.435] Future #4
[17:28:17.436] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:28:17.436] - nx: 4
[17:28:17.436] - relay: TRUE
[17:28:17.436] - stdout: TRUE
[17:28:17.436] - signal: TRUE
[17:28:17.436] - resignal: FALSE
[17:28:17.436] - force: TRUE
[17:28:17.437] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.437] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.437]  - until=4
[17:28:17.437]  - relaying element #4
[17:28:17.437] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.438] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.438] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:28:17.438]  length: 0 (resolved future 4)
[17:28:17.438] Relaying remaining futures
[17:28:17.438] signalConditionsASAP(NULL, pos=0) ...
[17:28:17.438] - nx: 4
[17:28:17.438] - relay: TRUE
[17:28:17.439] - stdout: TRUE
[17:28:17.439] - signal: TRUE
[17:28:17.439] - resignal: FALSE
[17:28:17.439] - force: TRUE
[17:28:17.439] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.439] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:28:17.440] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.440] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.440] signalConditionsASAP(NULL, pos=0) ... done
[17:28:17.440] resolve() on list ... DONE
[[1]]
[1] 0

[[2]]
[1] 1

[[3]]
[1] 2

[[4]]
[1] 0

[17:28:17.441] getGlobalsAndPackages() ...
[17:28:17.441] Searching for globals...
[17:28:17.443] - globals found: [3] '{', 'sample', 'x'
[17:28:17.443] Searching for globals ... DONE
[17:28:17.443] Resolving globals: FALSE
[17:28:17.444] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.444] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.445] - globals: [1] 'x'
[17:28:17.445] 
[17:28:17.445] getGlobalsAndPackages() ... DONE
[17:28:17.445] run() for 'Future' ...
[17:28:17.445] - state: 'created'
[17:28:17.446] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.446] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.446] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.446]   - Field: 'label'
[17:28:17.446]   - Field: 'local'
[17:28:17.447]   - Field: 'owner'
[17:28:17.447]   - Field: 'envir'
[17:28:17.447]   - Field: 'packages'
[17:28:17.447]   - Field: 'gc'
[17:28:17.447]   - Field: 'conditions'
[17:28:17.447]   - Field: 'expr'
[17:28:17.448]   - Field: 'uuid'
[17:28:17.448]   - Field: 'seed'
[17:28:17.448]   - Field: 'version'
[17:28:17.448]   - Field: 'result'
[17:28:17.448]   - Field: 'asynchronous'
[17:28:17.449]   - Field: 'calls'
[17:28:17.449]   - Field: 'globals'
[17:28:17.449]   - Field: 'stdout'
[17:28:17.449]   - Field: 'earlySignal'
[17:28:17.449]   - Field: 'lazy'
[17:28:17.450]   - Field: 'state'
[17:28:17.450] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.450] - Launch lazy future ...
[17:28:17.450] Packages needed by the future expression (n = 0): <none>
[17:28:17.450] Packages needed by future strategies (n = 0): <none>
[17:28:17.451] {
[17:28:17.451]     {
[17:28:17.451]         {
[17:28:17.451]             ...future.startTime <- base::Sys.time()
[17:28:17.451]             {
[17:28:17.451]                 {
[17:28:17.451]                   {
[17:28:17.451]                     base::local({
[17:28:17.451]                       has_future <- base::requireNamespace("future", 
[17:28:17.451]                         quietly = TRUE)
[17:28:17.451]                       if (has_future) {
[17:28:17.451]                         ns <- base::getNamespace("future")
[17:28:17.451]                         version <- ns[[".package"]][["version"]]
[17:28:17.451]                         if (is.null(version)) 
[17:28:17.451]                           version <- utils::packageVersion("future")
[17:28:17.451]                       }
[17:28:17.451]                       else {
[17:28:17.451]                         version <- NULL
[17:28:17.451]                       }
[17:28:17.451]                       if (!has_future || version < "1.8.0") {
[17:28:17.451]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.451]                           "", base::R.version$version.string), 
[17:28:17.451]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.451]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.451]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.451]                             "release", "version")], collapse = " "), 
[17:28:17.451]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.451]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.451]                           info)
[17:28:17.451]                         info <- base::paste(info, collapse = "; ")
[17:28:17.451]                         if (!has_future) {
[17:28:17.451]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.451]                             info)
[17:28:17.451]                         }
[17:28:17.451]                         else {
[17:28:17.451]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.451]                             info, version)
[17:28:17.451]                         }
[17:28:17.451]                         base::stop(msg)
[17:28:17.451]                       }
[17:28:17.451]                     })
[17:28:17.451]                   }
[17:28:17.451]                   ...future.strategy.old <- future::plan("list")
[17:28:17.451]                   options(future.plan = NULL)
[17:28:17.451]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.451]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.451]                 }
[17:28:17.451]                 ...future.workdir <- getwd()
[17:28:17.451]             }
[17:28:17.451]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.451]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.451]         }
[17:28:17.451]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.451]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.451]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.451]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.451]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.451]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.451]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.451]             base::names(...future.oldOptions))
[17:28:17.451]     }
[17:28:17.451]     if (FALSE) {
[17:28:17.451]     }
[17:28:17.451]     else {
[17:28:17.451]         if (TRUE) {
[17:28:17.451]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.451]                 open = "w")
[17:28:17.451]         }
[17:28:17.451]         else {
[17:28:17.451]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.451]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.451]         }
[17:28:17.451]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.451]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.451]             base::sink(type = "output", split = FALSE)
[17:28:17.451]             base::close(...future.stdout)
[17:28:17.451]         }, add = TRUE)
[17:28:17.451]     }
[17:28:17.451]     ...future.frame <- base::sys.nframe()
[17:28:17.451]     ...future.conditions <- base::list()
[17:28:17.451]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.451]     if (FALSE) {
[17:28:17.451]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.451]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.451]     }
[17:28:17.451]     ...future.result <- base::tryCatch({
[17:28:17.451]         base::withCallingHandlers({
[17:28:17.451]             ...future.value <- base::withVisible(base::local({
[17:28:17.451]                 sample(x, size = 1L)
[17:28:17.451]             }))
[17:28:17.451]             future::FutureResult(value = ...future.value$value, 
[17:28:17.451]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.451]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.451]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.451]                     ...future.globalenv.names))
[17:28:17.451]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.451]         }, condition = base::local({
[17:28:17.451]             c <- base::c
[17:28:17.451]             inherits <- base::inherits
[17:28:17.451]             invokeRestart <- base::invokeRestart
[17:28:17.451]             length <- base::length
[17:28:17.451]             list <- base::list
[17:28:17.451]             seq.int <- base::seq.int
[17:28:17.451]             signalCondition <- base::signalCondition
[17:28:17.451]             sys.calls <- base::sys.calls
[17:28:17.451]             `[[` <- base::`[[`
[17:28:17.451]             `+` <- base::`+`
[17:28:17.451]             `<<-` <- base::`<<-`
[17:28:17.451]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.451]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.451]                   3L)]
[17:28:17.451]             }
[17:28:17.451]             function(cond) {
[17:28:17.451]                 is_error <- inherits(cond, "error")
[17:28:17.451]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.451]                   NULL)
[17:28:17.451]                 if (is_error) {
[17:28:17.451]                   sessionInformation <- function() {
[17:28:17.451]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.451]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.451]                       search = base::search(), system = base::Sys.info())
[17:28:17.451]                   }
[17:28:17.451]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.451]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.451]                     cond$call), session = sessionInformation(), 
[17:28:17.451]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.451]                   signalCondition(cond)
[17:28:17.451]                 }
[17:28:17.451]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.451]                 "immediateCondition"))) {
[17:28:17.451]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.451]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.451]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.451]                   if (TRUE && !signal) {
[17:28:17.451]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.451]                     {
[17:28:17.451]                       inherits <- base::inherits
[17:28:17.451]                       invokeRestart <- base::invokeRestart
[17:28:17.451]                       is.null <- base::is.null
[17:28:17.451]                       muffled <- FALSE
[17:28:17.451]                       if (inherits(cond, "message")) {
[17:28:17.451]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.451]                         if (muffled) 
[17:28:17.451]                           invokeRestart("muffleMessage")
[17:28:17.451]                       }
[17:28:17.451]                       else if (inherits(cond, "warning")) {
[17:28:17.451]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.451]                         if (muffled) 
[17:28:17.451]                           invokeRestart("muffleWarning")
[17:28:17.451]                       }
[17:28:17.451]                       else if (inherits(cond, "condition")) {
[17:28:17.451]                         if (!is.null(pattern)) {
[17:28:17.451]                           computeRestarts <- base::computeRestarts
[17:28:17.451]                           grepl <- base::grepl
[17:28:17.451]                           restarts <- computeRestarts(cond)
[17:28:17.451]                           for (restart in restarts) {
[17:28:17.451]                             name <- restart$name
[17:28:17.451]                             if (is.null(name)) 
[17:28:17.451]                               next
[17:28:17.451]                             if (!grepl(pattern, name)) 
[17:28:17.451]                               next
[17:28:17.451]                             invokeRestart(restart)
[17:28:17.451]                             muffled <- TRUE
[17:28:17.451]                             break
[17:28:17.451]                           }
[17:28:17.451]                         }
[17:28:17.451]                       }
[17:28:17.451]                       invisible(muffled)
[17:28:17.451]                     }
[17:28:17.451]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.451]                   }
[17:28:17.451]                 }
[17:28:17.451]                 else {
[17:28:17.451]                   if (TRUE) {
[17:28:17.451]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.451]                     {
[17:28:17.451]                       inherits <- base::inherits
[17:28:17.451]                       invokeRestart <- base::invokeRestart
[17:28:17.451]                       is.null <- base::is.null
[17:28:17.451]                       muffled <- FALSE
[17:28:17.451]                       if (inherits(cond, "message")) {
[17:28:17.451]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.451]                         if (muffled) 
[17:28:17.451]                           invokeRestart("muffleMessage")
[17:28:17.451]                       }
[17:28:17.451]                       else if (inherits(cond, "warning")) {
[17:28:17.451]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.451]                         if (muffled) 
[17:28:17.451]                           invokeRestart("muffleWarning")
[17:28:17.451]                       }
[17:28:17.451]                       else if (inherits(cond, "condition")) {
[17:28:17.451]                         if (!is.null(pattern)) {
[17:28:17.451]                           computeRestarts <- base::computeRestarts
[17:28:17.451]                           grepl <- base::grepl
[17:28:17.451]                           restarts <- computeRestarts(cond)
[17:28:17.451]                           for (restart in restarts) {
[17:28:17.451]                             name <- restart$name
[17:28:17.451]                             if (is.null(name)) 
[17:28:17.451]                               next
[17:28:17.451]                             if (!grepl(pattern, name)) 
[17:28:17.451]                               next
[17:28:17.451]                             invokeRestart(restart)
[17:28:17.451]                             muffled <- TRUE
[17:28:17.451]                             break
[17:28:17.451]                           }
[17:28:17.451]                         }
[17:28:17.451]                       }
[17:28:17.451]                       invisible(muffled)
[17:28:17.451]                     }
[17:28:17.451]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.451]                   }
[17:28:17.451]                 }
[17:28:17.451]             }
[17:28:17.451]         }))
[17:28:17.451]     }, error = function(ex) {
[17:28:17.451]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.451]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.451]                 ...future.rng), started = ...future.startTime, 
[17:28:17.451]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.451]             version = "1.8"), class = "FutureResult")
[17:28:17.451]     }, finally = {
[17:28:17.451]         if (!identical(...future.workdir, getwd())) 
[17:28:17.451]             setwd(...future.workdir)
[17:28:17.451]         {
[17:28:17.451]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.451]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.451]             }
[17:28:17.451]             base::options(...future.oldOptions)
[17:28:17.451]             if (.Platform$OS.type == "windows") {
[17:28:17.451]                 old_names <- names(...future.oldEnvVars)
[17:28:17.451]                 envs <- base::Sys.getenv()
[17:28:17.451]                 names <- names(envs)
[17:28:17.451]                 common <- intersect(names, old_names)
[17:28:17.451]                 added <- setdiff(names, old_names)
[17:28:17.451]                 removed <- setdiff(old_names, names)
[17:28:17.451]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.451]                   envs[common]]
[17:28:17.451]                 NAMES <- toupper(changed)
[17:28:17.451]                 args <- list()
[17:28:17.451]                 for (kk in seq_along(NAMES)) {
[17:28:17.451]                   name <- changed[[kk]]
[17:28:17.451]                   NAME <- NAMES[[kk]]
[17:28:17.451]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.451]                     next
[17:28:17.451]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.451]                 }
[17:28:17.451]                 NAMES <- toupper(added)
[17:28:17.451]                 for (kk in seq_along(NAMES)) {
[17:28:17.451]                   name <- added[[kk]]
[17:28:17.451]                   NAME <- NAMES[[kk]]
[17:28:17.451]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.451]                     next
[17:28:17.451]                   args[[name]] <- ""
[17:28:17.451]                 }
[17:28:17.451]                 NAMES <- toupper(removed)
[17:28:17.451]                 for (kk in seq_along(NAMES)) {
[17:28:17.451]                   name <- removed[[kk]]
[17:28:17.451]                   NAME <- NAMES[[kk]]
[17:28:17.451]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.451]                     next
[17:28:17.451]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.451]                 }
[17:28:17.451]                 if (length(args) > 0) 
[17:28:17.451]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.451]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.451]             }
[17:28:17.451]             else {
[17:28:17.451]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.451]             }
[17:28:17.451]             {
[17:28:17.451]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.451]                   0L) {
[17:28:17.451]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.451]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.451]                   base::options(opts)
[17:28:17.451]                 }
[17:28:17.451]                 {
[17:28:17.451]                   {
[17:28:17.451]                     base::assign(".Random.seed", c(10407L, 2047656601L, 
[17:28:17.451]                     -1391193963L, -1632727667L, -1586534332L, 
[17:28:17.451]                     -471806345L, 865592900L), envir = base::globalenv(), 
[17:28:17.451]                       inherits = FALSE)
[17:28:17.451]                     NULL
[17:28:17.451]                   }
[17:28:17.451]                   options(future.plan = NULL)
[17:28:17.451]                   if (is.na(NA_character_)) 
[17:28:17.451]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.451]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.451]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.451]                     .init = FALSE)
[17:28:17.451]                 }
[17:28:17.451]             }
[17:28:17.451]         }
[17:28:17.451]     })
[17:28:17.451]     if (TRUE) {
[17:28:17.451]         base::sink(type = "output", split = FALSE)
[17:28:17.451]         if (TRUE) {
[17:28:17.451]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.451]         }
[17:28:17.451]         else {
[17:28:17.451]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.451]         }
[17:28:17.451]         base::close(...future.stdout)
[17:28:17.451]         ...future.stdout <- NULL
[17:28:17.451]     }
[17:28:17.451]     ...future.result$conditions <- ...future.conditions
[17:28:17.451]     ...future.result$finished <- base::Sys.time()
[17:28:17.451]     ...future.result
[17:28:17.451] }
[17:28:17.455] assign_globals() ...
[17:28:17.455] List of 1
[17:28:17.455]  $ x: int [1:4] 0 1 2 3
[17:28:17.455]  - attr(*, "where")=List of 1
[17:28:17.455]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.455]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.455]  - attr(*, "resolved")= logi FALSE
[17:28:17.455]  - attr(*, "total_size")= num 64
[17:28:17.455]  - attr(*, "already-done")= logi TRUE
[17:28:17.458] - copied 'x' to environment
[17:28:17.458] assign_globals() ... done
[17:28:17.458] plan(): Setting new future strategy stack:
[17:28:17.458] List of future strategies:
[17:28:17.458] 1. sequential:
[17:28:17.458]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.458]    - tweaked: FALSE
[17:28:17.458]    - call: NULL
[17:28:17.459] plan(): nbrOfWorkers() = 1
[17:28:17.460] plan(): Setting new future strategy stack:
[17:28:17.460] List of future strategies:
[17:28:17.460] 1. sequential:
[17:28:17.460]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.460]    - tweaked: FALSE
[17:28:17.460]    - call: plan(strategy)
[17:28:17.461] plan(): nbrOfWorkers() = 1
[17:28:17.461] SequentialFuture started (and completed)
[17:28:17.461] - Launch lazy future ... done
[17:28:17.461] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-224023'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x0000026673dad3a8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.462] getGlobalsAndPackages() ...
[17:28:17.463] Searching for globals...
[17:28:17.464] - globals found: [3] '{', 'sample', 'x'
[17:28:17.464] Searching for globals ... DONE
[17:28:17.464] Resolving globals: FALSE
[17:28:17.465] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.465] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.465] - globals: [1] 'x'
[17:28:17.465] 
[17:28:17.466] getGlobalsAndPackages() ... DONE
[17:28:17.466] run() for 'Future' ...
[17:28:17.466] - state: 'created'
[17:28:17.466] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.467] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.467] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.467]   - Field: 'label'
[17:28:17.467]   - Field: 'local'
[17:28:17.467]   - Field: 'owner'
[17:28:17.467]   - Field: 'envir'
[17:28:17.468]   - Field: 'packages'
[17:28:17.468]   - Field: 'gc'
[17:28:17.468]   - Field: 'conditions'
[17:28:17.468]   - Field: 'expr'
[17:28:17.468]   - Field: 'uuid'
[17:28:17.469]   - Field: 'seed'
[17:28:17.469]   - Field: 'version'
[17:28:17.469]   - Field: 'result'
[17:28:17.469]   - Field: 'asynchronous'
[17:28:17.469]   - Field: 'calls'
[17:28:17.469]   - Field: 'globals'
[17:28:17.470]   - Field: 'stdout'
[17:28:17.470]   - Field: 'earlySignal'
[17:28:17.470]   - Field: 'lazy'
[17:28:17.470]   - Field: 'state'
[17:28:17.470] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.470] - Launch lazy future ...
[17:28:17.471] Packages needed by the future expression (n = 0): <none>
[17:28:17.471] Packages needed by future strategies (n = 0): <none>
[17:28:17.471] {
[17:28:17.471]     {
[17:28:17.471]         {
[17:28:17.471]             ...future.startTime <- base::Sys.time()
[17:28:17.471]             {
[17:28:17.471]                 {
[17:28:17.471]                   {
[17:28:17.471]                     base::local({
[17:28:17.471]                       has_future <- base::requireNamespace("future", 
[17:28:17.471]                         quietly = TRUE)
[17:28:17.471]                       if (has_future) {
[17:28:17.471]                         ns <- base::getNamespace("future")
[17:28:17.471]                         version <- ns[[".package"]][["version"]]
[17:28:17.471]                         if (is.null(version)) 
[17:28:17.471]                           version <- utils::packageVersion("future")
[17:28:17.471]                       }
[17:28:17.471]                       else {
[17:28:17.471]                         version <- NULL
[17:28:17.471]                       }
[17:28:17.471]                       if (!has_future || version < "1.8.0") {
[17:28:17.471]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.471]                           "", base::R.version$version.string), 
[17:28:17.471]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.471]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.471]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.471]                             "release", "version")], collapse = " "), 
[17:28:17.471]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.471]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.471]                           info)
[17:28:17.471]                         info <- base::paste(info, collapse = "; ")
[17:28:17.471]                         if (!has_future) {
[17:28:17.471]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.471]                             info)
[17:28:17.471]                         }
[17:28:17.471]                         else {
[17:28:17.471]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.471]                             info, version)
[17:28:17.471]                         }
[17:28:17.471]                         base::stop(msg)
[17:28:17.471]                       }
[17:28:17.471]                     })
[17:28:17.471]                   }
[17:28:17.471]                   ...future.strategy.old <- future::plan("list")
[17:28:17.471]                   options(future.plan = NULL)
[17:28:17.471]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.471]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.471]                 }
[17:28:17.471]                 ...future.workdir <- getwd()
[17:28:17.471]             }
[17:28:17.471]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.471]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.471]         }
[17:28:17.471]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.471]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.471]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.471]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.471]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.471]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.471]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.471]             base::names(...future.oldOptions))
[17:28:17.471]     }
[17:28:17.471]     if (FALSE) {
[17:28:17.471]     }
[17:28:17.471]     else {
[17:28:17.471]         if (TRUE) {
[17:28:17.471]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.471]                 open = "w")
[17:28:17.471]         }
[17:28:17.471]         else {
[17:28:17.471]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.471]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.471]         }
[17:28:17.471]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.471]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.471]             base::sink(type = "output", split = FALSE)
[17:28:17.471]             base::close(...future.stdout)
[17:28:17.471]         }, add = TRUE)
[17:28:17.471]     }
[17:28:17.471]     ...future.frame <- base::sys.nframe()
[17:28:17.471]     ...future.conditions <- base::list()
[17:28:17.471]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.471]     if (FALSE) {
[17:28:17.471]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.471]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.471]     }
[17:28:17.471]     ...future.result <- base::tryCatch({
[17:28:17.471]         base::withCallingHandlers({
[17:28:17.471]             ...future.value <- base::withVisible(base::local({
[17:28:17.471]                 sample(x, size = 1L)
[17:28:17.471]             }))
[17:28:17.471]             future::FutureResult(value = ...future.value$value, 
[17:28:17.471]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.471]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.471]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.471]                     ...future.globalenv.names))
[17:28:17.471]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.471]         }, condition = base::local({
[17:28:17.471]             c <- base::c
[17:28:17.471]             inherits <- base::inherits
[17:28:17.471]             invokeRestart <- base::invokeRestart
[17:28:17.471]             length <- base::length
[17:28:17.471]             list <- base::list
[17:28:17.471]             seq.int <- base::seq.int
[17:28:17.471]             signalCondition <- base::signalCondition
[17:28:17.471]             sys.calls <- base::sys.calls
[17:28:17.471]             `[[` <- base::`[[`
[17:28:17.471]             `+` <- base::`+`
[17:28:17.471]             `<<-` <- base::`<<-`
[17:28:17.471]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.471]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.471]                   3L)]
[17:28:17.471]             }
[17:28:17.471]             function(cond) {
[17:28:17.471]                 is_error <- inherits(cond, "error")
[17:28:17.471]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.471]                   NULL)
[17:28:17.471]                 if (is_error) {
[17:28:17.471]                   sessionInformation <- function() {
[17:28:17.471]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.471]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.471]                       search = base::search(), system = base::Sys.info())
[17:28:17.471]                   }
[17:28:17.471]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.471]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.471]                     cond$call), session = sessionInformation(), 
[17:28:17.471]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.471]                   signalCondition(cond)
[17:28:17.471]                 }
[17:28:17.471]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.471]                 "immediateCondition"))) {
[17:28:17.471]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.471]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.471]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.471]                   if (TRUE && !signal) {
[17:28:17.471]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.471]                     {
[17:28:17.471]                       inherits <- base::inherits
[17:28:17.471]                       invokeRestart <- base::invokeRestart
[17:28:17.471]                       is.null <- base::is.null
[17:28:17.471]                       muffled <- FALSE
[17:28:17.471]                       if (inherits(cond, "message")) {
[17:28:17.471]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.471]                         if (muffled) 
[17:28:17.471]                           invokeRestart("muffleMessage")
[17:28:17.471]                       }
[17:28:17.471]                       else if (inherits(cond, "warning")) {
[17:28:17.471]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.471]                         if (muffled) 
[17:28:17.471]                           invokeRestart("muffleWarning")
[17:28:17.471]                       }
[17:28:17.471]                       else if (inherits(cond, "condition")) {
[17:28:17.471]                         if (!is.null(pattern)) {
[17:28:17.471]                           computeRestarts <- base::computeRestarts
[17:28:17.471]                           grepl <- base::grepl
[17:28:17.471]                           restarts <- computeRestarts(cond)
[17:28:17.471]                           for (restart in restarts) {
[17:28:17.471]                             name <- restart$name
[17:28:17.471]                             if (is.null(name)) 
[17:28:17.471]                               next
[17:28:17.471]                             if (!grepl(pattern, name)) 
[17:28:17.471]                               next
[17:28:17.471]                             invokeRestart(restart)
[17:28:17.471]                             muffled <- TRUE
[17:28:17.471]                             break
[17:28:17.471]                           }
[17:28:17.471]                         }
[17:28:17.471]                       }
[17:28:17.471]                       invisible(muffled)
[17:28:17.471]                     }
[17:28:17.471]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.471]                   }
[17:28:17.471]                 }
[17:28:17.471]                 else {
[17:28:17.471]                   if (TRUE) {
[17:28:17.471]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.471]                     {
[17:28:17.471]                       inherits <- base::inherits
[17:28:17.471]                       invokeRestart <- base::invokeRestart
[17:28:17.471]                       is.null <- base::is.null
[17:28:17.471]                       muffled <- FALSE
[17:28:17.471]                       if (inherits(cond, "message")) {
[17:28:17.471]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.471]                         if (muffled) 
[17:28:17.471]                           invokeRestart("muffleMessage")
[17:28:17.471]                       }
[17:28:17.471]                       else if (inherits(cond, "warning")) {
[17:28:17.471]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.471]                         if (muffled) 
[17:28:17.471]                           invokeRestart("muffleWarning")
[17:28:17.471]                       }
[17:28:17.471]                       else if (inherits(cond, "condition")) {
[17:28:17.471]                         if (!is.null(pattern)) {
[17:28:17.471]                           computeRestarts <- base::computeRestarts
[17:28:17.471]                           grepl <- base::grepl
[17:28:17.471]                           restarts <- computeRestarts(cond)
[17:28:17.471]                           for (restart in restarts) {
[17:28:17.471]                             name <- restart$name
[17:28:17.471]                             if (is.null(name)) 
[17:28:17.471]                               next
[17:28:17.471]                             if (!grepl(pattern, name)) 
[17:28:17.471]                               next
[17:28:17.471]                             invokeRestart(restart)
[17:28:17.471]                             muffled <- TRUE
[17:28:17.471]                             break
[17:28:17.471]                           }
[17:28:17.471]                         }
[17:28:17.471]                       }
[17:28:17.471]                       invisible(muffled)
[17:28:17.471]                     }
[17:28:17.471]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.471]                   }
[17:28:17.471]                 }
[17:28:17.471]             }
[17:28:17.471]         }))
[17:28:17.471]     }, error = function(ex) {
[17:28:17.471]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.471]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.471]                 ...future.rng), started = ...future.startTime, 
[17:28:17.471]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.471]             version = "1.8"), class = "FutureResult")
[17:28:17.471]     }, finally = {
[17:28:17.471]         if (!identical(...future.workdir, getwd())) 
[17:28:17.471]             setwd(...future.workdir)
[17:28:17.471]         {
[17:28:17.471]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.471]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.471]             }
[17:28:17.471]             base::options(...future.oldOptions)
[17:28:17.471]             if (.Platform$OS.type == "windows") {
[17:28:17.471]                 old_names <- names(...future.oldEnvVars)
[17:28:17.471]                 envs <- base::Sys.getenv()
[17:28:17.471]                 names <- names(envs)
[17:28:17.471]                 common <- intersect(names, old_names)
[17:28:17.471]                 added <- setdiff(names, old_names)
[17:28:17.471]                 removed <- setdiff(old_names, names)
[17:28:17.471]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.471]                   envs[common]]
[17:28:17.471]                 NAMES <- toupper(changed)
[17:28:17.471]                 args <- list()
[17:28:17.471]                 for (kk in seq_along(NAMES)) {
[17:28:17.471]                   name <- changed[[kk]]
[17:28:17.471]                   NAME <- NAMES[[kk]]
[17:28:17.471]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.471]                     next
[17:28:17.471]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.471]                 }
[17:28:17.471]                 NAMES <- toupper(added)
[17:28:17.471]                 for (kk in seq_along(NAMES)) {
[17:28:17.471]                   name <- added[[kk]]
[17:28:17.471]                   NAME <- NAMES[[kk]]
[17:28:17.471]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.471]                     next
[17:28:17.471]                   args[[name]] <- ""
[17:28:17.471]                 }
[17:28:17.471]                 NAMES <- toupper(removed)
[17:28:17.471]                 for (kk in seq_along(NAMES)) {
[17:28:17.471]                   name <- removed[[kk]]
[17:28:17.471]                   NAME <- NAMES[[kk]]
[17:28:17.471]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.471]                     next
[17:28:17.471]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.471]                 }
[17:28:17.471]                 if (length(args) > 0) 
[17:28:17.471]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.471]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.471]             }
[17:28:17.471]             else {
[17:28:17.471]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.471]             }
[17:28:17.471]             {
[17:28:17.471]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.471]                   0L) {
[17:28:17.471]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.471]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.471]                   base::options(opts)
[17:28:17.471]                 }
[17:28:17.471]                 {
[17:28:17.471]                   {
[17:28:17.471]                     base::assign(".Random.seed", c(10407L, -1632727667L, 
[17:28:17.471]                     1654911898L, 1881022227L, 865592900L, 697753043L, 
[17:28:17.471]                     1914436937L), envir = base::globalenv(), 
[17:28:17.471]                       inherits = FALSE)
[17:28:17.471]                     NULL
[17:28:17.471]                   }
[17:28:17.471]                   options(future.plan = NULL)
[17:28:17.471]                   if (is.na(NA_character_)) 
[17:28:17.471]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.471]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.471]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.471]                     .init = FALSE)
[17:28:17.471]                 }
[17:28:17.471]             }
[17:28:17.471]         }
[17:28:17.471]     })
[17:28:17.471]     if (TRUE) {
[17:28:17.471]         base::sink(type = "output", split = FALSE)
[17:28:17.471]         if (TRUE) {
[17:28:17.471]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.471]         }
[17:28:17.471]         else {
[17:28:17.471]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.471]         }
[17:28:17.471]         base::close(...future.stdout)
[17:28:17.471]         ...future.stdout <- NULL
[17:28:17.471]     }
[17:28:17.471]     ...future.result$conditions <- ...future.conditions
[17:28:17.471]     ...future.result$finished <- base::Sys.time()
[17:28:17.471]     ...future.result
[17:28:17.471] }
[17:28:17.475] assign_globals() ...
[17:28:17.475] List of 1
[17:28:17.475]  $ x: int [1:4] 0 1 2 3
[17:28:17.475]  - attr(*, "where")=List of 1
[17:28:17.475]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.475]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.475]  - attr(*, "resolved")= logi FALSE
[17:28:17.475]  - attr(*, "total_size")= num 64
[17:28:17.475]  - attr(*, "already-done")= logi TRUE
[17:28:17.479] - copied 'x' to environment
[17:28:17.480] assign_globals() ... done
[17:28:17.480] plan(): Setting new future strategy stack:
[17:28:17.480] List of future strategies:
[17:28:17.480] 1. sequential:
[17:28:17.480]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.480]    - tweaked: FALSE
[17:28:17.480]    - call: NULL
[17:28:17.481] plan(): nbrOfWorkers() = 1
[17:28:17.482] plan(): Setting new future strategy stack:
[17:28:17.482] List of future strategies:
[17:28:17.482] 1. sequential:
[17:28:17.482]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.482]    - tweaked: FALSE
[17:28:17.482]    - call: plan(strategy)
[17:28:17.483] plan(): nbrOfWorkers() = 1
[17:28:17.483] SequentialFuture started (and completed)
[17:28:17.483] - Launch lazy future ... done
[17:28:17.483] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-916995'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x0000026673dad3a8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.484] getGlobalsAndPackages() ...
[17:28:17.484] Searching for globals...
[17:28:17.485] - globals found: [3] '{', 'sample', 'x'
[17:28:17.486] Searching for globals ... DONE
[17:28:17.486] Resolving globals: FALSE
[17:28:17.486] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.487] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.487] - globals: [1] 'x'
[17:28:17.487] 
[17:28:17.487] getGlobalsAndPackages() ... DONE
[17:28:17.488] run() for 'Future' ...
[17:28:17.488] - state: 'created'
[17:28:17.488] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.488] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.488] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.489]   - Field: 'label'
[17:28:17.489]   - Field: 'local'
[17:28:17.489]   - Field: 'owner'
[17:28:17.489]   - Field: 'envir'
[17:28:17.489]   - Field: 'packages'
[17:28:17.490]   - Field: 'gc'
[17:28:17.490]   - Field: 'conditions'
[17:28:17.490]   - Field: 'expr'
[17:28:17.490]   - Field: 'uuid'
[17:28:17.490]   - Field: 'seed'
[17:28:17.490]   - Field: 'version'
[17:28:17.491]   - Field: 'result'
[17:28:17.491]   - Field: 'asynchronous'
[17:28:17.491]   - Field: 'calls'
[17:28:17.491]   - Field: 'globals'
[17:28:17.491]   - Field: 'stdout'
[17:28:17.491]   - Field: 'earlySignal'
[17:28:17.492]   - Field: 'lazy'
[17:28:17.492]   - Field: 'state'
[17:28:17.492] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.492] - Launch lazy future ...
[17:28:17.492] Packages needed by the future expression (n = 0): <none>
[17:28:17.493] Packages needed by future strategies (n = 0): <none>
[17:28:17.493] {
[17:28:17.493]     {
[17:28:17.493]         {
[17:28:17.493]             ...future.startTime <- base::Sys.time()
[17:28:17.493]             {
[17:28:17.493]                 {
[17:28:17.493]                   {
[17:28:17.493]                     base::local({
[17:28:17.493]                       has_future <- base::requireNamespace("future", 
[17:28:17.493]                         quietly = TRUE)
[17:28:17.493]                       if (has_future) {
[17:28:17.493]                         ns <- base::getNamespace("future")
[17:28:17.493]                         version <- ns[[".package"]][["version"]]
[17:28:17.493]                         if (is.null(version)) 
[17:28:17.493]                           version <- utils::packageVersion("future")
[17:28:17.493]                       }
[17:28:17.493]                       else {
[17:28:17.493]                         version <- NULL
[17:28:17.493]                       }
[17:28:17.493]                       if (!has_future || version < "1.8.0") {
[17:28:17.493]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.493]                           "", base::R.version$version.string), 
[17:28:17.493]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.493]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.493]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.493]                             "release", "version")], collapse = " "), 
[17:28:17.493]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.493]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.493]                           info)
[17:28:17.493]                         info <- base::paste(info, collapse = "; ")
[17:28:17.493]                         if (!has_future) {
[17:28:17.493]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.493]                             info)
[17:28:17.493]                         }
[17:28:17.493]                         else {
[17:28:17.493]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.493]                             info, version)
[17:28:17.493]                         }
[17:28:17.493]                         base::stop(msg)
[17:28:17.493]                       }
[17:28:17.493]                     })
[17:28:17.493]                   }
[17:28:17.493]                   ...future.strategy.old <- future::plan("list")
[17:28:17.493]                   options(future.plan = NULL)
[17:28:17.493]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.493]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.493]                 }
[17:28:17.493]                 ...future.workdir <- getwd()
[17:28:17.493]             }
[17:28:17.493]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.493]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.493]         }
[17:28:17.493]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.493]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.493]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.493]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.493]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.493]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.493]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.493]             base::names(...future.oldOptions))
[17:28:17.493]     }
[17:28:17.493]     if (FALSE) {
[17:28:17.493]     }
[17:28:17.493]     else {
[17:28:17.493]         if (TRUE) {
[17:28:17.493]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.493]                 open = "w")
[17:28:17.493]         }
[17:28:17.493]         else {
[17:28:17.493]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.493]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.493]         }
[17:28:17.493]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.493]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.493]             base::sink(type = "output", split = FALSE)
[17:28:17.493]             base::close(...future.stdout)
[17:28:17.493]         }, add = TRUE)
[17:28:17.493]     }
[17:28:17.493]     ...future.frame <- base::sys.nframe()
[17:28:17.493]     ...future.conditions <- base::list()
[17:28:17.493]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.493]     if (FALSE) {
[17:28:17.493]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.493]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.493]     }
[17:28:17.493]     ...future.result <- base::tryCatch({
[17:28:17.493]         base::withCallingHandlers({
[17:28:17.493]             ...future.value <- base::withVisible(base::local({
[17:28:17.493]                 sample(x, size = 1L)
[17:28:17.493]             }))
[17:28:17.493]             future::FutureResult(value = ...future.value$value, 
[17:28:17.493]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.493]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.493]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.493]                     ...future.globalenv.names))
[17:28:17.493]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.493]         }, condition = base::local({
[17:28:17.493]             c <- base::c
[17:28:17.493]             inherits <- base::inherits
[17:28:17.493]             invokeRestart <- base::invokeRestart
[17:28:17.493]             length <- base::length
[17:28:17.493]             list <- base::list
[17:28:17.493]             seq.int <- base::seq.int
[17:28:17.493]             signalCondition <- base::signalCondition
[17:28:17.493]             sys.calls <- base::sys.calls
[17:28:17.493]             `[[` <- base::`[[`
[17:28:17.493]             `+` <- base::`+`
[17:28:17.493]             `<<-` <- base::`<<-`
[17:28:17.493]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.493]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.493]                   3L)]
[17:28:17.493]             }
[17:28:17.493]             function(cond) {
[17:28:17.493]                 is_error <- inherits(cond, "error")
[17:28:17.493]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.493]                   NULL)
[17:28:17.493]                 if (is_error) {
[17:28:17.493]                   sessionInformation <- function() {
[17:28:17.493]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.493]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.493]                       search = base::search(), system = base::Sys.info())
[17:28:17.493]                   }
[17:28:17.493]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.493]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.493]                     cond$call), session = sessionInformation(), 
[17:28:17.493]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.493]                   signalCondition(cond)
[17:28:17.493]                 }
[17:28:17.493]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.493]                 "immediateCondition"))) {
[17:28:17.493]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.493]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.493]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.493]                   if (TRUE && !signal) {
[17:28:17.493]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.493]                     {
[17:28:17.493]                       inherits <- base::inherits
[17:28:17.493]                       invokeRestart <- base::invokeRestart
[17:28:17.493]                       is.null <- base::is.null
[17:28:17.493]                       muffled <- FALSE
[17:28:17.493]                       if (inherits(cond, "message")) {
[17:28:17.493]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.493]                         if (muffled) 
[17:28:17.493]                           invokeRestart("muffleMessage")
[17:28:17.493]                       }
[17:28:17.493]                       else if (inherits(cond, "warning")) {
[17:28:17.493]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.493]                         if (muffled) 
[17:28:17.493]                           invokeRestart("muffleWarning")
[17:28:17.493]                       }
[17:28:17.493]                       else if (inherits(cond, "condition")) {
[17:28:17.493]                         if (!is.null(pattern)) {
[17:28:17.493]                           computeRestarts <- base::computeRestarts
[17:28:17.493]                           grepl <- base::grepl
[17:28:17.493]                           restarts <- computeRestarts(cond)
[17:28:17.493]                           for (restart in restarts) {
[17:28:17.493]                             name <- restart$name
[17:28:17.493]                             if (is.null(name)) 
[17:28:17.493]                               next
[17:28:17.493]                             if (!grepl(pattern, name)) 
[17:28:17.493]                               next
[17:28:17.493]                             invokeRestart(restart)
[17:28:17.493]                             muffled <- TRUE
[17:28:17.493]                             break
[17:28:17.493]                           }
[17:28:17.493]                         }
[17:28:17.493]                       }
[17:28:17.493]                       invisible(muffled)
[17:28:17.493]                     }
[17:28:17.493]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.493]                   }
[17:28:17.493]                 }
[17:28:17.493]                 else {
[17:28:17.493]                   if (TRUE) {
[17:28:17.493]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.493]                     {
[17:28:17.493]                       inherits <- base::inherits
[17:28:17.493]                       invokeRestart <- base::invokeRestart
[17:28:17.493]                       is.null <- base::is.null
[17:28:17.493]                       muffled <- FALSE
[17:28:17.493]                       if (inherits(cond, "message")) {
[17:28:17.493]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.493]                         if (muffled) 
[17:28:17.493]                           invokeRestart("muffleMessage")
[17:28:17.493]                       }
[17:28:17.493]                       else if (inherits(cond, "warning")) {
[17:28:17.493]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.493]                         if (muffled) 
[17:28:17.493]                           invokeRestart("muffleWarning")
[17:28:17.493]                       }
[17:28:17.493]                       else if (inherits(cond, "condition")) {
[17:28:17.493]                         if (!is.null(pattern)) {
[17:28:17.493]                           computeRestarts <- base::computeRestarts
[17:28:17.493]                           grepl <- base::grepl
[17:28:17.493]                           restarts <- computeRestarts(cond)
[17:28:17.493]                           for (restart in restarts) {
[17:28:17.493]                             name <- restart$name
[17:28:17.493]                             if (is.null(name)) 
[17:28:17.493]                               next
[17:28:17.493]                             if (!grepl(pattern, name)) 
[17:28:17.493]                               next
[17:28:17.493]                             invokeRestart(restart)
[17:28:17.493]                             muffled <- TRUE
[17:28:17.493]                             break
[17:28:17.493]                           }
[17:28:17.493]                         }
[17:28:17.493]                       }
[17:28:17.493]                       invisible(muffled)
[17:28:17.493]                     }
[17:28:17.493]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.493]                   }
[17:28:17.493]                 }
[17:28:17.493]             }
[17:28:17.493]         }))
[17:28:17.493]     }, error = function(ex) {
[17:28:17.493]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.493]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.493]                 ...future.rng), started = ...future.startTime, 
[17:28:17.493]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.493]             version = "1.8"), class = "FutureResult")
[17:28:17.493]     }, finally = {
[17:28:17.493]         if (!identical(...future.workdir, getwd())) 
[17:28:17.493]             setwd(...future.workdir)
[17:28:17.493]         {
[17:28:17.493]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.493]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.493]             }
[17:28:17.493]             base::options(...future.oldOptions)
[17:28:17.493]             if (.Platform$OS.type == "windows") {
[17:28:17.493]                 old_names <- names(...future.oldEnvVars)
[17:28:17.493]                 envs <- base::Sys.getenv()
[17:28:17.493]                 names <- names(envs)
[17:28:17.493]                 common <- intersect(names, old_names)
[17:28:17.493]                 added <- setdiff(names, old_names)
[17:28:17.493]                 removed <- setdiff(old_names, names)
[17:28:17.493]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.493]                   envs[common]]
[17:28:17.493]                 NAMES <- toupper(changed)
[17:28:17.493]                 args <- list()
[17:28:17.493]                 for (kk in seq_along(NAMES)) {
[17:28:17.493]                   name <- changed[[kk]]
[17:28:17.493]                   NAME <- NAMES[[kk]]
[17:28:17.493]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.493]                     next
[17:28:17.493]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.493]                 }
[17:28:17.493]                 NAMES <- toupper(added)
[17:28:17.493]                 for (kk in seq_along(NAMES)) {
[17:28:17.493]                   name <- added[[kk]]
[17:28:17.493]                   NAME <- NAMES[[kk]]
[17:28:17.493]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.493]                     next
[17:28:17.493]                   args[[name]] <- ""
[17:28:17.493]                 }
[17:28:17.493]                 NAMES <- toupper(removed)
[17:28:17.493]                 for (kk in seq_along(NAMES)) {
[17:28:17.493]                   name <- removed[[kk]]
[17:28:17.493]                   NAME <- NAMES[[kk]]
[17:28:17.493]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.493]                     next
[17:28:17.493]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.493]                 }
[17:28:17.493]                 if (length(args) > 0) 
[17:28:17.493]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.493]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.493]             }
[17:28:17.493]             else {
[17:28:17.493]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.493]             }
[17:28:17.493]             {
[17:28:17.493]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.493]                   0L) {
[17:28:17.493]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.493]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.493]                   base::options(opts)
[17:28:17.493]                 }
[17:28:17.493]                 {
[17:28:17.493]                   {
[17:28:17.493]                     base::assign(".Random.seed", c(10407L, 1881022227L, 
[17:28:17.493]                     -962939424L, 1544586554L, 1914436937L, -1916429131L, 
[17:28:17.493]                     -1969451661L), envir = base::globalenv(), 
[17:28:17.493]                       inherits = FALSE)
[17:28:17.493]                     NULL
[17:28:17.493]                   }
[17:28:17.493]                   options(future.plan = NULL)
[17:28:17.493]                   if (is.na(NA_character_)) 
[17:28:17.493]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.493]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.493]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.493]                     .init = FALSE)
[17:28:17.493]                 }
[17:28:17.493]             }
[17:28:17.493]         }
[17:28:17.493]     })
[17:28:17.493]     if (TRUE) {
[17:28:17.493]         base::sink(type = "output", split = FALSE)
[17:28:17.493]         if (TRUE) {
[17:28:17.493]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.493]         }
[17:28:17.493]         else {
[17:28:17.493]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.493]         }
[17:28:17.493]         base::close(...future.stdout)
[17:28:17.493]         ...future.stdout <- NULL
[17:28:17.493]     }
[17:28:17.493]     ...future.result$conditions <- ...future.conditions
[17:28:17.493]     ...future.result$finished <- base::Sys.time()
[17:28:17.493]     ...future.result
[17:28:17.493] }
[17:28:17.497] assign_globals() ...
[17:28:17.497] List of 1
[17:28:17.497]  $ x: int [1:4] 0 1 2 3
[17:28:17.497]  - attr(*, "where")=List of 1
[17:28:17.497]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.497]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.497]  - attr(*, "resolved")= logi FALSE
[17:28:17.497]  - attr(*, "total_size")= num 64
[17:28:17.497]  - attr(*, "already-done")= logi TRUE
[17:28:17.500] - copied 'x' to environment
[17:28:17.500] assign_globals() ... done
[17:28:17.500] plan(): Setting new future strategy stack:
[17:28:17.501] List of future strategies:
[17:28:17.501] 1. sequential:
[17:28:17.501]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.501]    - tweaked: FALSE
[17:28:17.501]    - call: NULL
[17:28:17.501] plan(): nbrOfWorkers() = 1
[17:28:17.502] plan(): Setting new future strategy stack:
[17:28:17.503] List of future strategies:
[17:28:17.503] 1. sequential:
[17:28:17.503]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.503]    - tweaked: FALSE
[17:28:17.503]    - call: plan(strategy)
[17:28:17.503] plan(): nbrOfWorkers() = 1
[17:28:17.503] SequentialFuture started (and completed)
[17:28:17.504] - Launch lazy future ... done
[17:28:17.504] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-381300'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x0000026673dad3a8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.505] getGlobalsAndPackages() ...
[17:28:17.505] Searching for globals...
[17:28:17.506] - globals found: [3] '{', 'sample', 'x'
[17:28:17.507] Searching for globals ... DONE
[17:28:17.507] Resolving globals: FALSE
[17:28:17.508] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.508] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.509] - globals: [1] 'x'
[17:28:17.509] 
[17:28:17.509] getGlobalsAndPackages() ... DONE
[17:28:17.509] run() for 'Future' ...
[17:28:17.509] - state: 'created'
[17:28:17.510] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.510] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.510] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.510]   - Field: 'label'
[17:28:17.510]   - Field: 'local'
[17:28:17.511]   - Field: 'owner'
[17:28:17.511]   - Field: 'envir'
[17:28:17.511]   - Field: 'packages'
[17:28:17.511]   - Field: 'gc'
[17:28:17.511]   - Field: 'conditions'
[17:28:17.512]   - Field: 'expr'
[17:28:17.512]   - Field: 'uuid'
[17:28:17.512]   - Field: 'seed'
[17:28:17.512]   - Field: 'version'
[17:28:17.512]   - Field: 'result'
[17:28:17.512]   - Field: 'asynchronous'
[17:28:17.513]   - Field: 'calls'
[17:28:17.513]   - Field: 'globals'
[17:28:17.513]   - Field: 'stdout'
[17:28:17.513]   - Field: 'earlySignal'
[17:28:17.513]   - Field: 'lazy'
[17:28:17.513]   - Field: 'state'
[17:28:17.514] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.514] - Launch lazy future ...
[17:28:17.514] Packages needed by the future expression (n = 0): <none>
[17:28:17.514] Packages needed by future strategies (n = 0): <none>
[17:28:17.515] {
[17:28:17.515]     {
[17:28:17.515]         {
[17:28:17.515]             ...future.startTime <- base::Sys.time()
[17:28:17.515]             {
[17:28:17.515]                 {
[17:28:17.515]                   {
[17:28:17.515]                     base::local({
[17:28:17.515]                       has_future <- base::requireNamespace("future", 
[17:28:17.515]                         quietly = TRUE)
[17:28:17.515]                       if (has_future) {
[17:28:17.515]                         ns <- base::getNamespace("future")
[17:28:17.515]                         version <- ns[[".package"]][["version"]]
[17:28:17.515]                         if (is.null(version)) 
[17:28:17.515]                           version <- utils::packageVersion("future")
[17:28:17.515]                       }
[17:28:17.515]                       else {
[17:28:17.515]                         version <- NULL
[17:28:17.515]                       }
[17:28:17.515]                       if (!has_future || version < "1.8.0") {
[17:28:17.515]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.515]                           "", base::R.version$version.string), 
[17:28:17.515]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.515]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.515]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.515]                             "release", "version")], collapse = " "), 
[17:28:17.515]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.515]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.515]                           info)
[17:28:17.515]                         info <- base::paste(info, collapse = "; ")
[17:28:17.515]                         if (!has_future) {
[17:28:17.515]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.515]                             info)
[17:28:17.515]                         }
[17:28:17.515]                         else {
[17:28:17.515]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.515]                             info, version)
[17:28:17.515]                         }
[17:28:17.515]                         base::stop(msg)
[17:28:17.515]                       }
[17:28:17.515]                     })
[17:28:17.515]                   }
[17:28:17.515]                   ...future.strategy.old <- future::plan("list")
[17:28:17.515]                   options(future.plan = NULL)
[17:28:17.515]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.515]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.515]                 }
[17:28:17.515]                 ...future.workdir <- getwd()
[17:28:17.515]             }
[17:28:17.515]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.515]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.515]         }
[17:28:17.515]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.515]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.515]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.515]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.515]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.515]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.515]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.515]             base::names(...future.oldOptions))
[17:28:17.515]     }
[17:28:17.515]     if (FALSE) {
[17:28:17.515]     }
[17:28:17.515]     else {
[17:28:17.515]         if (TRUE) {
[17:28:17.515]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.515]                 open = "w")
[17:28:17.515]         }
[17:28:17.515]         else {
[17:28:17.515]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.515]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.515]         }
[17:28:17.515]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.515]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.515]             base::sink(type = "output", split = FALSE)
[17:28:17.515]             base::close(...future.stdout)
[17:28:17.515]         }, add = TRUE)
[17:28:17.515]     }
[17:28:17.515]     ...future.frame <- base::sys.nframe()
[17:28:17.515]     ...future.conditions <- base::list()
[17:28:17.515]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.515]     if (FALSE) {
[17:28:17.515]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.515]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.515]     }
[17:28:17.515]     ...future.result <- base::tryCatch({
[17:28:17.515]         base::withCallingHandlers({
[17:28:17.515]             ...future.value <- base::withVisible(base::local({
[17:28:17.515]                 sample(x, size = 1L)
[17:28:17.515]             }))
[17:28:17.515]             future::FutureResult(value = ...future.value$value, 
[17:28:17.515]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.515]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.515]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.515]                     ...future.globalenv.names))
[17:28:17.515]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.515]         }, condition = base::local({
[17:28:17.515]             c <- base::c
[17:28:17.515]             inherits <- base::inherits
[17:28:17.515]             invokeRestart <- base::invokeRestart
[17:28:17.515]             length <- base::length
[17:28:17.515]             list <- base::list
[17:28:17.515]             seq.int <- base::seq.int
[17:28:17.515]             signalCondition <- base::signalCondition
[17:28:17.515]             sys.calls <- base::sys.calls
[17:28:17.515]             `[[` <- base::`[[`
[17:28:17.515]             `+` <- base::`+`
[17:28:17.515]             `<<-` <- base::`<<-`
[17:28:17.515]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.515]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.515]                   3L)]
[17:28:17.515]             }
[17:28:17.515]             function(cond) {
[17:28:17.515]                 is_error <- inherits(cond, "error")
[17:28:17.515]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.515]                   NULL)
[17:28:17.515]                 if (is_error) {
[17:28:17.515]                   sessionInformation <- function() {
[17:28:17.515]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.515]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.515]                       search = base::search(), system = base::Sys.info())
[17:28:17.515]                   }
[17:28:17.515]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.515]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.515]                     cond$call), session = sessionInformation(), 
[17:28:17.515]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.515]                   signalCondition(cond)
[17:28:17.515]                 }
[17:28:17.515]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.515]                 "immediateCondition"))) {
[17:28:17.515]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.515]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.515]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.515]                   if (TRUE && !signal) {
[17:28:17.515]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.515]                     {
[17:28:17.515]                       inherits <- base::inherits
[17:28:17.515]                       invokeRestart <- base::invokeRestart
[17:28:17.515]                       is.null <- base::is.null
[17:28:17.515]                       muffled <- FALSE
[17:28:17.515]                       if (inherits(cond, "message")) {
[17:28:17.515]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.515]                         if (muffled) 
[17:28:17.515]                           invokeRestart("muffleMessage")
[17:28:17.515]                       }
[17:28:17.515]                       else if (inherits(cond, "warning")) {
[17:28:17.515]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.515]                         if (muffled) 
[17:28:17.515]                           invokeRestart("muffleWarning")
[17:28:17.515]                       }
[17:28:17.515]                       else if (inherits(cond, "condition")) {
[17:28:17.515]                         if (!is.null(pattern)) {
[17:28:17.515]                           computeRestarts <- base::computeRestarts
[17:28:17.515]                           grepl <- base::grepl
[17:28:17.515]                           restarts <- computeRestarts(cond)
[17:28:17.515]                           for (restart in restarts) {
[17:28:17.515]                             name <- restart$name
[17:28:17.515]                             if (is.null(name)) 
[17:28:17.515]                               next
[17:28:17.515]                             if (!grepl(pattern, name)) 
[17:28:17.515]                               next
[17:28:17.515]                             invokeRestart(restart)
[17:28:17.515]                             muffled <- TRUE
[17:28:17.515]                             break
[17:28:17.515]                           }
[17:28:17.515]                         }
[17:28:17.515]                       }
[17:28:17.515]                       invisible(muffled)
[17:28:17.515]                     }
[17:28:17.515]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.515]                   }
[17:28:17.515]                 }
[17:28:17.515]                 else {
[17:28:17.515]                   if (TRUE) {
[17:28:17.515]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.515]                     {
[17:28:17.515]                       inherits <- base::inherits
[17:28:17.515]                       invokeRestart <- base::invokeRestart
[17:28:17.515]                       is.null <- base::is.null
[17:28:17.515]                       muffled <- FALSE
[17:28:17.515]                       if (inherits(cond, "message")) {
[17:28:17.515]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.515]                         if (muffled) 
[17:28:17.515]                           invokeRestart("muffleMessage")
[17:28:17.515]                       }
[17:28:17.515]                       else if (inherits(cond, "warning")) {
[17:28:17.515]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.515]                         if (muffled) 
[17:28:17.515]                           invokeRestart("muffleWarning")
[17:28:17.515]                       }
[17:28:17.515]                       else if (inherits(cond, "condition")) {
[17:28:17.515]                         if (!is.null(pattern)) {
[17:28:17.515]                           computeRestarts <- base::computeRestarts
[17:28:17.515]                           grepl <- base::grepl
[17:28:17.515]                           restarts <- computeRestarts(cond)
[17:28:17.515]                           for (restart in restarts) {
[17:28:17.515]                             name <- restart$name
[17:28:17.515]                             if (is.null(name)) 
[17:28:17.515]                               next
[17:28:17.515]                             if (!grepl(pattern, name)) 
[17:28:17.515]                               next
[17:28:17.515]                             invokeRestart(restart)
[17:28:17.515]                             muffled <- TRUE
[17:28:17.515]                             break
[17:28:17.515]                           }
[17:28:17.515]                         }
[17:28:17.515]                       }
[17:28:17.515]                       invisible(muffled)
[17:28:17.515]                     }
[17:28:17.515]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.515]                   }
[17:28:17.515]                 }
[17:28:17.515]             }
[17:28:17.515]         }))
[17:28:17.515]     }, error = function(ex) {
[17:28:17.515]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.515]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.515]                 ...future.rng), started = ...future.startTime, 
[17:28:17.515]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.515]             version = "1.8"), class = "FutureResult")
[17:28:17.515]     }, finally = {
[17:28:17.515]         if (!identical(...future.workdir, getwd())) 
[17:28:17.515]             setwd(...future.workdir)
[17:28:17.515]         {
[17:28:17.515]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.515]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.515]             }
[17:28:17.515]             base::options(...future.oldOptions)
[17:28:17.515]             if (.Platform$OS.type == "windows") {
[17:28:17.515]                 old_names <- names(...future.oldEnvVars)
[17:28:17.515]                 envs <- base::Sys.getenv()
[17:28:17.515]                 names <- names(envs)
[17:28:17.515]                 common <- intersect(names, old_names)
[17:28:17.515]                 added <- setdiff(names, old_names)
[17:28:17.515]                 removed <- setdiff(old_names, names)
[17:28:17.515]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.515]                   envs[common]]
[17:28:17.515]                 NAMES <- toupper(changed)
[17:28:17.515]                 args <- list()
[17:28:17.515]                 for (kk in seq_along(NAMES)) {
[17:28:17.515]                   name <- changed[[kk]]
[17:28:17.515]                   NAME <- NAMES[[kk]]
[17:28:17.515]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.515]                     next
[17:28:17.515]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.515]                 }
[17:28:17.515]                 NAMES <- toupper(added)
[17:28:17.515]                 for (kk in seq_along(NAMES)) {
[17:28:17.515]                   name <- added[[kk]]
[17:28:17.515]                   NAME <- NAMES[[kk]]
[17:28:17.515]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.515]                     next
[17:28:17.515]                   args[[name]] <- ""
[17:28:17.515]                 }
[17:28:17.515]                 NAMES <- toupper(removed)
[17:28:17.515]                 for (kk in seq_along(NAMES)) {
[17:28:17.515]                   name <- removed[[kk]]
[17:28:17.515]                   NAME <- NAMES[[kk]]
[17:28:17.515]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.515]                     next
[17:28:17.515]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.515]                 }
[17:28:17.515]                 if (length(args) > 0) 
[17:28:17.515]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.515]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.515]             }
[17:28:17.515]             else {
[17:28:17.515]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.515]             }
[17:28:17.515]             {
[17:28:17.515]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.515]                   0L) {
[17:28:17.515]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.515]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.515]                   base::options(opts)
[17:28:17.515]                 }
[17:28:17.515]                 {
[17:28:17.515]                   {
[17:28:17.515]                     base::assign(".Random.seed", c(10407L, 1544586554L, 
[17:28:17.515]                     -1109955828L, 235189556L, -1969451661L, -1276824933L, 
[17:28:17.515]                     -627630158L), envir = base::globalenv(), 
[17:28:17.515]                       inherits = FALSE)
[17:28:17.515]                     NULL
[17:28:17.515]                   }
[17:28:17.515]                   options(future.plan = NULL)
[17:28:17.515]                   if (is.na(NA_character_)) 
[17:28:17.515]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.515]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.515]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.515]                     .init = FALSE)
[17:28:17.515]                 }
[17:28:17.515]             }
[17:28:17.515]         }
[17:28:17.515]     })
[17:28:17.515]     if (TRUE) {
[17:28:17.515]         base::sink(type = "output", split = FALSE)
[17:28:17.515]         if (TRUE) {
[17:28:17.515]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.515]         }
[17:28:17.515]         else {
[17:28:17.515]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.515]         }
[17:28:17.515]         base::close(...future.stdout)
[17:28:17.515]         ...future.stdout <- NULL
[17:28:17.515]     }
[17:28:17.515]     ...future.result$conditions <- ...future.conditions
[17:28:17.515]     ...future.result$finished <- base::Sys.time()
[17:28:17.515]     ...future.result
[17:28:17.515] }
[17:28:17.518] assign_globals() ...
[17:28:17.518] List of 1
[17:28:17.518]  $ x: int [1:4] 0 1 2 3
[17:28:17.518]  - attr(*, "where")=List of 1
[17:28:17.518]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.518]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.518]  - attr(*, "resolved")= logi FALSE
[17:28:17.518]  - attr(*, "total_size")= num 64
[17:28:17.518]  - attr(*, "already-done")= logi TRUE
[17:28:17.521] - copied 'x' to environment
[17:28:17.522] assign_globals() ... done
[17:28:17.522] plan(): Setting new future strategy stack:
[17:28:17.522] List of future strategies:
[17:28:17.522] 1. sequential:
[17:28:17.522]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.522]    - tweaked: FALSE
[17:28:17.522]    - call: NULL
[17:28:17.523] plan(): nbrOfWorkers() = 1
[17:28:17.524] plan(): Setting new future strategy stack:
[17:28:17.524] List of future strategies:
[17:28:17.524] 1. sequential:
[17:28:17.524]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.524]    - tweaked: FALSE
[17:28:17.524]    - call: plan(strategy)
[17:28:17.525] plan(): nbrOfWorkers() = 1
[17:28:17.525] SequentialFuture started (and completed)
[17:28:17.525] - Launch lazy future ... done
[17:28:17.525] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-144238'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x0000026673dad3a8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.526] resolve() on list ...
[17:28:17.526]  recursive: 0
[17:28:17.526]  length: 4
[17:28:17.527] 
[17:28:17.527] resolved() for 'SequentialFuture' ...
[17:28:17.527] - state: 'finished'
[17:28:17.527] - run: TRUE
[17:28:17.527] - result: 'FutureResult'
[17:28:17.527] resolved() for 'SequentialFuture' ... done
[17:28:17.528] Future #1
[17:28:17.528] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:28:17.528] - nx: 4
[17:28:17.528] - relay: TRUE
[17:28:17.528] - stdout: TRUE
[17:28:17.528] - signal: TRUE
[17:28:17.529] - resignal: FALSE
[17:28:17.529] - force: TRUE
[17:28:17.529] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.529] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.529]  - until=1
[17:28:17.529]  - relaying element #1
[17:28:17.530] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.530] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.530] signalConditionsASAP(SequentialFuture, pos=1) ... done
[17:28:17.530]  length: 3 (resolved future 1)
[17:28:17.530] resolved() for 'SequentialFuture' ...
[17:28:17.531] - state: 'finished'
[17:28:17.531] - run: TRUE
[17:28:17.531] - result: 'FutureResult'
[17:28:17.531] resolved() for 'SequentialFuture' ... done
[17:28:17.531] Future #2
[17:28:17.531] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:28:17.532] - nx: 4
[17:28:17.532] - relay: TRUE
[17:28:17.532] - stdout: TRUE
[17:28:17.532] - signal: TRUE
[17:28:17.532] - resignal: FALSE
[17:28:17.532] - force: TRUE
[17:28:17.533] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.533] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.533]  - until=2
[17:28:17.533]  - relaying element #2
[17:28:17.533] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.533] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.534] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:28:17.534]  length: 2 (resolved future 2)
[17:28:17.534] resolved() for 'SequentialFuture' ...
[17:28:17.534] - state: 'finished'
[17:28:17.534] - run: TRUE
[17:28:17.535] - result: 'FutureResult'
[17:28:17.535] resolved() for 'SequentialFuture' ... done
[17:28:17.535] Future #3
[17:28:17.535] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:28:17.535] - nx: 4
[17:28:17.535] - relay: TRUE
[17:28:17.536] - stdout: TRUE
[17:28:17.536] - signal: TRUE
[17:28:17.536] - resignal: FALSE
[17:28:17.536] - force: TRUE
[17:28:17.536] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.536] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.536]  - until=3
[17:28:17.537]  - relaying element #3
[17:28:17.537] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.537] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.537] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:28:17.537]  length: 1 (resolved future 3)
[17:28:17.560] resolved() for 'SequentialFuture' ...
[17:28:17.560] - state: 'finished'
[17:28:17.560] - run: TRUE
[17:28:17.561] - result: 'FutureResult'
[17:28:17.561] resolved() for 'SequentialFuture' ... done
[17:28:17.561] Future #4
[17:28:17.561] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:28:17.561] - nx: 4
[17:28:17.562] - relay: TRUE
[17:28:17.562] - stdout: TRUE
[17:28:17.562] - signal: TRUE
[17:28:17.562] - resignal: FALSE
[17:28:17.562] - force: TRUE
[17:28:17.562] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.563] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.563]  - until=4
[17:28:17.563]  - relaying element #4
[17:28:17.563] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.563] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.563] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:28:17.564]  length: 0 (resolved future 4)
[17:28:17.564] Relaying remaining futures
[17:28:17.564] signalConditionsASAP(NULL, pos=0) ...
[17:28:17.564] - nx: 4
[17:28:17.564] - relay: TRUE
[17:28:17.564] - stdout: TRUE
[17:28:17.565] - signal: TRUE
[17:28:17.565] - resignal: FALSE
[17:28:17.565] - force: TRUE
[17:28:17.565] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.565] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:28:17.565] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.566] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.566] signalConditionsASAP(NULL, pos=0) ... done
[17:28:17.566] resolve() on list ... DONE
[[1]]
[1] 1

[[2]]
[1] 1

[[3]]
[1] 2

[[4]]
[1] 2

[17:28:17.567] getGlobalsAndPackages() ...
[17:28:17.567] Searching for globals...
[17:28:17.568] - globals found: [3] '{', 'sample', 'x'
[17:28:17.568] Searching for globals ... DONE
[17:28:17.568] Resolving globals: FALSE
[17:28:17.569] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.569] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.569] - globals: [1] 'x'
[17:28:17.570] 
[17:28:17.570] getGlobalsAndPackages() ... DONE
[17:28:17.570] run() for 'Future' ...
[17:28:17.570] - state: 'created'
[17:28:17.570] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.571] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.571] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.571]   - Field: 'label'
[17:28:17.571]   - Field: 'local'
[17:28:17.572]   - Field: 'owner'
[17:28:17.572]   - Field: 'envir'
[17:28:17.572]   - Field: 'packages'
[17:28:17.572]   - Field: 'gc'
[17:28:17.572]   - Field: 'conditions'
[17:28:17.572]   - Field: 'expr'
[17:28:17.573]   - Field: 'uuid'
[17:28:17.573]   - Field: 'seed'
[17:28:17.573]   - Field: 'version'
[17:28:17.573]   - Field: 'result'
[17:28:17.573]   - Field: 'asynchronous'
[17:28:17.573]   - Field: 'calls'
[17:28:17.574]   - Field: 'globals'
[17:28:17.574]   - Field: 'stdout'
[17:28:17.574]   - Field: 'earlySignal'
[17:28:17.574]   - Field: 'lazy'
[17:28:17.574]   - Field: 'state'
[17:28:17.575] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.575] - Launch lazy future ...
[17:28:17.575] Packages needed by the future expression (n = 0): <none>
[17:28:17.575] Packages needed by future strategies (n = 0): <none>
[17:28:17.576] {
[17:28:17.576]     {
[17:28:17.576]         {
[17:28:17.576]             ...future.startTime <- base::Sys.time()
[17:28:17.576]             {
[17:28:17.576]                 {
[17:28:17.576]                   {
[17:28:17.576]                     base::local({
[17:28:17.576]                       has_future <- base::requireNamespace("future", 
[17:28:17.576]                         quietly = TRUE)
[17:28:17.576]                       if (has_future) {
[17:28:17.576]                         ns <- base::getNamespace("future")
[17:28:17.576]                         version <- ns[[".package"]][["version"]]
[17:28:17.576]                         if (is.null(version)) 
[17:28:17.576]                           version <- utils::packageVersion("future")
[17:28:17.576]                       }
[17:28:17.576]                       else {
[17:28:17.576]                         version <- NULL
[17:28:17.576]                       }
[17:28:17.576]                       if (!has_future || version < "1.8.0") {
[17:28:17.576]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.576]                           "", base::R.version$version.string), 
[17:28:17.576]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.576]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.576]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.576]                             "release", "version")], collapse = " "), 
[17:28:17.576]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.576]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.576]                           info)
[17:28:17.576]                         info <- base::paste(info, collapse = "; ")
[17:28:17.576]                         if (!has_future) {
[17:28:17.576]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.576]                             info)
[17:28:17.576]                         }
[17:28:17.576]                         else {
[17:28:17.576]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.576]                             info, version)
[17:28:17.576]                         }
[17:28:17.576]                         base::stop(msg)
[17:28:17.576]                       }
[17:28:17.576]                     })
[17:28:17.576]                   }
[17:28:17.576]                   ...future.strategy.old <- future::plan("list")
[17:28:17.576]                   options(future.plan = NULL)
[17:28:17.576]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.576]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.576]                 }
[17:28:17.576]                 ...future.workdir <- getwd()
[17:28:17.576]             }
[17:28:17.576]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.576]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.576]         }
[17:28:17.576]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.576]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.576]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.576]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.576]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.576]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.576]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.576]             base::names(...future.oldOptions))
[17:28:17.576]     }
[17:28:17.576]     if (FALSE) {
[17:28:17.576]     }
[17:28:17.576]     else {
[17:28:17.576]         if (TRUE) {
[17:28:17.576]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.576]                 open = "w")
[17:28:17.576]         }
[17:28:17.576]         else {
[17:28:17.576]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.576]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.576]         }
[17:28:17.576]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.576]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.576]             base::sink(type = "output", split = FALSE)
[17:28:17.576]             base::close(...future.stdout)
[17:28:17.576]         }, add = TRUE)
[17:28:17.576]     }
[17:28:17.576]     ...future.frame <- base::sys.nframe()
[17:28:17.576]     ...future.conditions <- base::list()
[17:28:17.576]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.576]     if (FALSE) {
[17:28:17.576]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.576]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.576]     }
[17:28:17.576]     ...future.result <- base::tryCatch({
[17:28:17.576]         base::withCallingHandlers({
[17:28:17.576]             ...future.value <- base::withVisible(base::local({
[17:28:17.576]                 sample(x, size = 1L)
[17:28:17.576]             }))
[17:28:17.576]             future::FutureResult(value = ...future.value$value, 
[17:28:17.576]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.576]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.576]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.576]                     ...future.globalenv.names))
[17:28:17.576]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.576]         }, condition = base::local({
[17:28:17.576]             c <- base::c
[17:28:17.576]             inherits <- base::inherits
[17:28:17.576]             invokeRestart <- base::invokeRestart
[17:28:17.576]             length <- base::length
[17:28:17.576]             list <- base::list
[17:28:17.576]             seq.int <- base::seq.int
[17:28:17.576]             signalCondition <- base::signalCondition
[17:28:17.576]             sys.calls <- base::sys.calls
[17:28:17.576]             `[[` <- base::`[[`
[17:28:17.576]             `+` <- base::`+`
[17:28:17.576]             `<<-` <- base::`<<-`
[17:28:17.576]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.576]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.576]                   3L)]
[17:28:17.576]             }
[17:28:17.576]             function(cond) {
[17:28:17.576]                 is_error <- inherits(cond, "error")
[17:28:17.576]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.576]                   NULL)
[17:28:17.576]                 if (is_error) {
[17:28:17.576]                   sessionInformation <- function() {
[17:28:17.576]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.576]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.576]                       search = base::search(), system = base::Sys.info())
[17:28:17.576]                   }
[17:28:17.576]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.576]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.576]                     cond$call), session = sessionInformation(), 
[17:28:17.576]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.576]                   signalCondition(cond)
[17:28:17.576]                 }
[17:28:17.576]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.576]                 "immediateCondition"))) {
[17:28:17.576]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.576]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.576]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.576]                   if (TRUE && !signal) {
[17:28:17.576]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.576]                     {
[17:28:17.576]                       inherits <- base::inherits
[17:28:17.576]                       invokeRestart <- base::invokeRestart
[17:28:17.576]                       is.null <- base::is.null
[17:28:17.576]                       muffled <- FALSE
[17:28:17.576]                       if (inherits(cond, "message")) {
[17:28:17.576]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.576]                         if (muffled) 
[17:28:17.576]                           invokeRestart("muffleMessage")
[17:28:17.576]                       }
[17:28:17.576]                       else if (inherits(cond, "warning")) {
[17:28:17.576]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.576]                         if (muffled) 
[17:28:17.576]                           invokeRestart("muffleWarning")
[17:28:17.576]                       }
[17:28:17.576]                       else if (inherits(cond, "condition")) {
[17:28:17.576]                         if (!is.null(pattern)) {
[17:28:17.576]                           computeRestarts <- base::computeRestarts
[17:28:17.576]                           grepl <- base::grepl
[17:28:17.576]                           restarts <- computeRestarts(cond)
[17:28:17.576]                           for (restart in restarts) {
[17:28:17.576]                             name <- restart$name
[17:28:17.576]                             if (is.null(name)) 
[17:28:17.576]                               next
[17:28:17.576]                             if (!grepl(pattern, name)) 
[17:28:17.576]                               next
[17:28:17.576]                             invokeRestart(restart)
[17:28:17.576]                             muffled <- TRUE
[17:28:17.576]                             break
[17:28:17.576]                           }
[17:28:17.576]                         }
[17:28:17.576]                       }
[17:28:17.576]                       invisible(muffled)
[17:28:17.576]                     }
[17:28:17.576]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.576]                   }
[17:28:17.576]                 }
[17:28:17.576]                 else {
[17:28:17.576]                   if (TRUE) {
[17:28:17.576]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.576]                     {
[17:28:17.576]                       inherits <- base::inherits
[17:28:17.576]                       invokeRestart <- base::invokeRestart
[17:28:17.576]                       is.null <- base::is.null
[17:28:17.576]                       muffled <- FALSE
[17:28:17.576]                       if (inherits(cond, "message")) {
[17:28:17.576]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.576]                         if (muffled) 
[17:28:17.576]                           invokeRestart("muffleMessage")
[17:28:17.576]                       }
[17:28:17.576]                       else if (inherits(cond, "warning")) {
[17:28:17.576]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.576]                         if (muffled) 
[17:28:17.576]                           invokeRestart("muffleWarning")
[17:28:17.576]                       }
[17:28:17.576]                       else if (inherits(cond, "condition")) {
[17:28:17.576]                         if (!is.null(pattern)) {
[17:28:17.576]                           computeRestarts <- base::computeRestarts
[17:28:17.576]                           grepl <- base::grepl
[17:28:17.576]                           restarts <- computeRestarts(cond)
[17:28:17.576]                           for (restart in restarts) {
[17:28:17.576]                             name <- restart$name
[17:28:17.576]                             if (is.null(name)) 
[17:28:17.576]                               next
[17:28:17.576]                             if (!grepl(pattern, name)) 
[17:28:17.576]                               next
[17:28:17.576]                             invokeRestart(restart)
[17:28:17.576]                             muffled <- TRUE
[17:28:17.576]                             break
[17:28:17.576]                           }
[17:28:17.576]                         }
[17:28:17.576]                       }
[17:28:17.576]                       invisible(muffled)
[17:28:17.576]                     }
[17:28:17.576]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.576]                   }
[17:28:17.576]                 }
[17:28:17.576]             }
[17:28:17.576]         }))
[17:28:17.576]     }, error = function(ex) {
[17:28:17.576]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.576]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.576]                 ...future.rng), started = ...future.startTime, 
[17:28:17.576]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.576]             version = "1.8"), class = "FutureResult")
[17:28:17.576]     }, finally = {
[17:28:17.576]         if (!identical(...future.workdir, getwd())) 
[17:28:17.576]             setwd(...future.workdir)
[17:28:17.576]         {
[17:28:17.576]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.576]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.576]             }
[17:28:17.576]             base::options(...future.oldOptions)
[17:28:17.576]             if (.Platform$OS.type == "windows") {
[17:28:17.576]                 old_names <- names(...future.oldEnvVars)
[17:28:17.576]                 envs <- base::Sys.getenv()
[17:28:17.576]                 names <- names(envs)
[17:28:17.576]                 common <- intersect(names, old_names)
[17:28:17.576]                 added <- setdiff(names, old_names)
[17:28:17.576]                 removed <- setdiff(old_names, names)
[17:28:17.576]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.576]                   envs[common]]
[17:28:17.576]                 NAMES <- toupper(changed)
[17:28:17.576]                 args <- list()
[17:28:17.576]                 for (kk in seq_along(NAMES)) {
[17:28:17.576]                   name <- changed[[kk]]
[17:28:17.576]                   NAME <- NAMES[[kk]]
[17:28:17.576]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.576]                     next
[17:28:17.576]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.576]                 }
[17:28:17.576]                 NAMES <- toupper(added)
[17:28:17.576]                 for (kk in seq_along(NAMES)) {
[17:28:17.576]                   name <- added[[kk]]
[17:28:17.576]                   NAME <- NAMES[[kk]]
[17:28:17.576]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.576]                     next
[17:28:17.576]                   args[[name]] <- ""
[17:28:17.576]                 }
[17:28:17.576]                 NAMES <- toupper(removed)
[17:28:17.576]                 for (kk in seq_along(NAMES)) {
[17:28:17.576]                   name <- removed[[kk]]
[17:28:17.576]                   NAME <- NAMES[[kk]]
[17:28:17.576]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.576]                     next
[17:28:17.576]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.576]                 }
[17:28:17.576]                 if (length(args) > 0) 
[17:28:17.576]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.576]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.576]             }
[17:28:17.576]             else {
[17:28:17.576]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.576]             }
[17:28:17.576]             {
[17:28:17.576]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.576]                   0L) {
[17:28:17.576]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.576]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.576]                   base::options(opts)
[17:28:17.576]                 }
[17:28:17.576]                 {
[17:28:17.576]                   {
[17:28:17.576]                     base::assign(".Random.seed", c(10407L, -1860205550L, 
[17:28:17.576]                     -13577262L, 1187492596L, 517537009L, 191770270L, 
[17:28:17.576]                     -952290750L), envir = base::globalenv(), 
[17:28:17.576]                       inherits = FALSE)
[17:28:17.576]                     NULL
[17:28:17.576]                   }
[17:28:17.576]                   options(future.plan = NULL)
[17:28:17.576]                   if (is.na(NA_character_)) 
[17:28:17.576]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.576]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.576]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.576]                     .init = FALSE)
[17:28:17.576]                 }
[17:28:17.576]             }
[17:28:17.576]         }
[17:28:17.576]     })
[17:28:17.576]     if (TRUE) {
[17:28:17.576]         base::sink(type = "output", split = FALSE)
[17:28:17.576]         if (TRUE) {
[17:28:17.576]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.576]         }
[17:28:17.576]         else {
[17:28:17.576]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.576]         }
[17:28:17.576]         base::close(...future.stdout)
[17:28:17.576]         ...future.stdout <- NULL
[17:28:17.576]     }
[17:28:17.576]     ...future.result$conditions <- ...future.conditions
[17:28:17.576]     ...future.result$finished <- base::Sys.time()
[17:28:17.576]     ...future.result
[17:28:17.576] }
[17:28:17.579] assign_globals() ...
[17:28:17.580] List of 1
[17:28:17.580]  $ x: int [1:4] 0 1 2 3
[17:28:17.580]  - attr(*, "where")=List of 1
[17:28:17.580]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.580]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.580]  - attr(*, "resolved")= logi FALSE
[17:28:17.580]  - attr(*, "total_size")= num 64
[17:28:17.580]  - attr(*, "already-done")= logi TRUE
[17:28:17.582] - copied 'x' to environment
[17:28:17.583] assign_globals() ... done
[17:28:17.583] plan(): Setting new future strategy stack:
[17:28:17.583] List of future strategies:
[17:28:17.583] 1. sequential:
[17:28:17.583]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.583]    - tweaked: FALSE
[17:28:17.583]    - call: NULL
[17:28:17.584] plan(): nbrOfWorkers() = 1
[17:28:17.585] plan(): Setting new future strategy stack:
[17:28:17.585] List of future strategies:
[17:28:17.585] 1. sequential:
[17:28:17.585]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.585]    - tweaked: FALSE
[17:28:17.585]    - call: plan(strategy)
[17:28:17.586] plan(): nbrOfWorkers() = 1
[17:28:17.586] SequentialFuture started (and completed)
[17:28:17.586] - Launch lazy future ... done
[17:28:17.586] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-163723'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x00000266718940a0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.587] getGlobalsAndPackages() ...
[17:28:17.588] Searching for globals...
[17:28:17.589] - globals found: [3] '{', 'sample', 'x'
[17:28:17.589] Searching for globals ... DONE
[17:28:17.589] Resolving globals: FALSE
[17:28:17.589] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.590] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.590] - globals: [1] 'x'
[17:28:17.590] 
[17:28:17.590] getGlobalsAndPackages() ... DONE
[17:28:17.591] run() for 'Future' ...
[17:28:17.591] - state: 'created'
[17:28:17.591] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.592] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.592] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.592]   - Field: 'label'
[17:28:17.592]   - Field: 'local'
[17:28:17.592]   - Field: 'owner'
[17:28:17.592]   - Field: 'envir'
[17:28:17.593]   - Field: 'packages'
[17:28:17.593]   - Field: 'gc'
[17:28:17.593]   - Field: 'conditions'
[17:28:17.593]   - Field: 'expr'
[17:28:17.594]   - Field: 'uuid'
[17:28:17.594]   - Field: 'seed'
[17:28:17.594]   - Field: 'version'
[17:28:17.594]   - Field: 'result'
[17:28:17.594]   - Field: 'asynchronous'
[17:28:17.594]   - Field: 'calls'
[17:28:17.595]   - Field: 'globals'
[17:28:17.595]   - Field: 'stdout'
[17:28:17.596]   - Field: 'earlySignal'
[17:28:17.596]   - Field: 'lazy'
[17:28:17.596]   - Field: 'state'
[17:28:17.596] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.596] - Launch lazy future ...
[17:28:17.597] Packages needed by the future expression (n = 0): <none>
[17:28:17.597] Packages needed by future strategies (n = 0): <none>
[17:28:17.597] {
[17:28:17.597]     {
[17:28:17.597]         {
[17:28:17.597]             ...future.startTime <- base::Sys.time()
[17:28:17.597]             {
[17:28:17.597]                 {
[17:28:17.597]                   {
[17:28:17.597]                     base::local({
[17:28:17.597]                       has_future <- base::requireNamespace("future", 
[17:28:17.597]                         quietly = TRUE)
[17:28:17.597]                       if (has_future) {
[17:28:17.597]                         ns <- base::getNamespace("future")
[17:28:17.597]                         version <- ns[[".package"]][["version"]]
[17:28:17.597]                         if (is.null(version)) 
[17:28:17.597]                           version <- utils::packageVersion("future")
[17:28:17.597]                       }
[17:28:17.597]                       else {
[17:28:17.597]                         version <- NULL
[17:28:17.597]                       }
[17:28:17.597]                       if (!has_future || version < "1.8.0") {
[17:28:17.597]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.597]                           "", base::R.version$version.string), 
[17:28:17.597]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.597]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.597]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.597]                             "release", "version")], collapse = " "), 
[17:28:17.597]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.597]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.597]                           info)
[17:28:17.597]                         info <- base::paste(info, collapse = "; ")
[17:28:17.597]                         if (!has_future) {
[17:28:17.597]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.597]                             info)
[17:28:17.597]                         }
[17:28:17.597]                         else {
[17:28:17.597]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.597]                             info, version)
[17:28:17.597]                         }
[17:28:17.597]                         base::stop(msg)
[17:28:17.597]                       }
[17:28:17.597]                     })
[17:28:17.597]                   }
[17:28:17.597]                   ...future.strategy.old <- future::plan("list")
[17:28:17.597]                   options(future.plan = NULL)
[17:28:17.597]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.597]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.597]                 }
[17:28:17.597]                 ...future.workdir <- getwd()
[17:28:17.597]             }
[17:28:17.597]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.597]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.597]         }
[17:28:17.597]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.597]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.597]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.597]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.597]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.597]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.597]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.597]             base::names(...future.oldOptions))
[17:28:17.597]     }
[17:28:17.597]     if (FALSE) {
[17:28:17.597]     }
[17:28:17.597]     else {
[17:28:17.597]         if (TRUE) {
[17:28:17.597]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.597]                 open = "w")
[17:28:17.597]         }
[17:28:17.597]         else {
[17:28:17.597]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.597]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.597]         }
[17:28:17.597]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.597]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.597]             base::sink(type = "output", split = FALSE)
[17:28:17.597]             base::close(...future.stdout)
[17:28:17.597]         }, add = TRUE)
[17:28:17.597]     }
[17:28:17.597]     ...future.frame <- base::sys.nframe()
[17:28:17.597]     ...future.conditions <- base::list()
[17:28:17.597]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.597]     if (FALSE) {
[17:28:17.597]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.597]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.597]     }
[17:28:17.597]     ...future.result <- base::tryCatch({
[17:28:17.597]         base::withCallingHandlers({
[17:28:17.597]             ...future.value <- base::withVisible(base::local({
[17:28:17.597]                 sample(x, size = 1L)
[17:28:17.597]             }))
[17:28:17.597]             future::FutureResult(value = ...future.value$value, 
[17:28:17.597]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.597]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.597]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.597]                     ...future.globalenv.names))
[17:28:17.597]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.597]         }, condition = base::local({
[17:28:17.597]             c <- base::c
[17:28:17.597]             inherits <- base::inherits
[17:28:17.597]             invokeRestart <- base::invokeRestart
[17:28:17.597]             length <- base::length
[17:28:17.597]             list <- base::list
[17:28:17.597]             seq.int <- base::seq.int
[17:28:17.597]             signalCondition <- base::signalCondition
[17:28:17.597]             sys.calls <- base::sys.calls
[17:28:17.597]             `[[` <- base::`[[`
[17:28:17.597]             `+` <- base::`+`
[17:28:17.597]             `<<-` <- base::`<<-`
[17:28:17.597]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.597]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.597]                   3L)]
[17:28:17.597]             }
[17:28:17.597]             function(cond) {
[17:28:17.597]                 is_error <- inherits(cond, "error")
[17:28:17.597]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.597]                   NULL)
[17:28:17.597]                 if (is_error) {
[17:28:17.597]                   sessionInformation <- function() {
[17:28:17.597]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.597]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.597]                       search = base::search(), system = base::Sys.info())
[17:28:17.597]                   }
[17:28:17.597]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.597]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.597]                     cond$call), session = sessionInformation(), 
[17:28:17.597]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.597]                   signalCondition(cond)
[17:28:17.597]                 }
[17:28:17.597]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.597]                 "immediateCondition"))) {
[17:28:17.597]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.597]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.597]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.597]                   if (TRUE && !signal) {
[17:28:17.597]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.597]                     {
[17:28:17.597]                       inherits <- base::inherits
[17:28:17.597]                       invokeRestart <- base::invokeRestart
[17:28:17.597]                       is.null <- base::is.null
[17:28:17.597]                       muffled <- FALSE
[17:28:17.597]                       if (inherits(cond, "message")) {
[17:28:17.597]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.597]                         if (muffled) 
[17:28:17.597]                           invokeRestart("muffleMessage")
[17:28:17.597]                       }
[17:28:17.597]                       else if (inherits(cond, "warning")) {
[17:28:17.597]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.597]                         if (muffled) 
[17:28:17.597]                           invokeRestart("muffleWarning")
[17:28:17.597]                       }
[17:28:17.597]                       else if (inherits(cond, "condition")) {
[17:28:17.597]                         if (!is.null(pattern)) {
[17:28:17.597]                           computeRestarts <- base::computeRestarts
[17:28:17.597]                           grepl <- base::grepl
[17:28:17.597]                           restarts <- computeRestarts(cond)
[17:28:17.597]                           for (restart in restarts) {
[17:28:17.597]                             name <- restart$name
[17:28:17.597]                             if (is.null(name)) 
[17:28:17.597]                               next
[17:28:17.597]                             if (!grepl(pattern, name)) 
[17:28:17.597]                               next
[17:28:17.597]                             invokeRestart(restart)
[17:28:17.597]                             muffled <- TRUE
[17:28:17.597]                             break
[17:28:17.597]                           }
[17:28:17.597]                         }
[17:28:17.597]                       }
[17:28:17.597]                       invisible(muffled)
[17:28:17.597]                     }
[17:28:17.597]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.597]                   }
[17:28:17.597]                 }
[17:28:17.597]                 else {
[17:28:17.597]                   if (TRUE) {
[17:28:17.597]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.597]                     {
[17:28:17.597]                       inherits <- base::inherits
[17:28:17.597]                       invokeRestart <- base::invokeRestart
[17:28:17.597]                       is.null <- base::is.null
[17:28:17.597]                       muffled <- FALSE
[17:28:17.597]                       if (inherits(cond, "message")) {
[17:28:17.597]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.597]                         if (muffled) 
[17:28:17.597]                           invokeRestart("muffleMessage")
[17:28:17.597]                       }
[17:28:17.597]                       else if (inherits(cond, "warning")) {
[17:28:17.597]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.597]                         if (muffled) 
[17:28:17.597]                           invokeRestart("muffleWarning")
[17:28:17.597]                       }
[17:28:17.597]                       else if (inherits(cond, "condition")) {
[17:28:17.597]                         if (!is.null(pattern)) {
[17:28:17.597]                           computeRestarts <- base::computeRestarts
[17:28:17.597]                           grepl <- base::grepl
[17:28:17.597]                           restarts <- computeRestarts(cond)
[17:28:17.597]                           for (restart in restarts) {
[17:28:17.597]                             name <- restart$name
[17:28:17.597]                             if (is.null(name)) 
[17:28:17.597]                               next
[17:28:17.597]                             if (!grepl(pattern, name)) 
[17:28:17.597]                               next
[17:28:17.597]                             invokeRestart(restart)
[17:28:17.597]                             muffled <- TRUE
[17:28:17.597]                             break
[17:28:17.597]                           }
[17:28:17.597]                         }
[17:28:17.597]                       }
[17:28:17.597]                       invisible(muffled)
[17:28:17.597]                     }
[17:28:17.597]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.597]                   }
[17:28:17.597]                 }
[17:28:17.597]             }
[17:28:17.597]         }))
[17:28:17.597]     }, error = function(ex) {
[17:28:17.597]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.597]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.597]                 ...future.rng), started = ...future.startTime, 
[17:28:17.597]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.597]             version = "1.8"), class = "FutureResult")
[17:28:17.597]     }, finally = {
[17:28:17.597]         if (!identical(...future.workdir, getwd())) 
[17:28:17.597]             setwd(...future.workdir)
[17:28:17.597]         {
[17:28:17.597]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.597]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.597]             }
[17:28:17.597]             base::options(...future.oldOptions)
[17:28:17.597]             if (.Platform$OS.type == "windows") {
[17:28:17.597]                 old_names <- names(...future.oldEnvVars)
[17:28:17.597]                 envs <- base::Sys.getenv()
[17:28:17.597]                 names <- names(envs)
[17:28:17.597]                 common <- intersect(names, old_names)
[17:28:17.597]                 added <- setdiff(names, old_names)
[17:28:17.597]                 removed <- setdiff(old_names, names)
[17:28:17.597]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.597]                   envs[common]]
[17:28:17.597]                 NAMES <- toupper(changed)
[17:28:17.597]                 args <- list()
[17:28:17.597]                 for (kk in seq_along(NAMES)) {
[17:28:17.597]                   name <- changed[[kk]]
[17:28:17.597]                   NAME <- NAMES[[kk]]
[17:28:17.597]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.597]                     next
[17:28:17.597]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.597]                 }
[17:28:17.597]                 NAMES <- toupper(added)
[17:28:17.597]                 for (kk in seq_along(NAMES)) {
[17:28:17.597]                   name <- added[[kk]]
[17:28:17.597]                   NAME <- NAMES[[kk]]
[17:28:17.597]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.597]                     next
[17:28:17.597]                   args[[name]] <- ""
[17:28:17.597]                 }
[17:28:17.597]                 NAMES <- toupper(removed)
[17:28:17.597]                 for (kk in seq_along(NAMES)) {
[17:28:17.597]                   name <- removed[[kk]]
[17:28:17.597]                   NAME <- NAMES[[kk]]
[17:28:17.597]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.597]                     next
[17:28:17.597]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.597]                 }
[17:28:17.597]                 if (length(args) > 0) 
[17:28:17.597]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.597]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.597]             }
[17:28:17.597]             else {
[17:28:17.597]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.597]             }
[17:28:17.597]             {
[17:28:17.597]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.597]                   0L) {
[17:28:17.597]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.597]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.597]                   base::options(opts)
[17:28:17.597]                 }
[17:28:17.597]                 {
[17:28:17.597]                   {
[17:28:17.597]                     base::assign(".Random.seed", c(10407L, 1187492596L, 
[17:28:17.597]                     -1013414601L, 866756367L, -952290750L, -55952870L, 
[17:28:17.597]                     707627690L), envir = base::globalenv(), inherits = FALSE)
[17:28:17.597]                     NULL
[17:28:17.597]                   }
[17:28:17.597]                   options(future.plan = NULL)
[17:28:17.597]                   if (is.na(NA_character_)) 
[17:28:17.597]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.597]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.597]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.597]                     .init = FALSE)
[17:28:17.597]                 }
[17:28:17.597]             }
[17:28:17.597]         }
[17:28:17.597]     })
[17:28:17.597]     if (TRUE) {
[17:28:17.597]         base::sink(type = "output", split = FALSE)
[17:28:17.597]         if (TRUE) {
[17:28:17.597]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.597]         }
[17:28:17.597]         else {
[17:28:17.597]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.597]         }
[17:28:17.597]         base::close(...future.stdout)
[17:28:17.597]         ...future.stdout <- NULL
[17:28:17.597]     }
[17:28:17.597]     ...future.result$conditions <- ...future.conditions
[17:28:17.597]     ...future.result$finished <- base::Sys.time()
[17:28:17.597]     ...future.result
[17:28:17.597] }
[17:28:17.601] assign_globals() ...
[17:28:17.601] List of 1
[17:28:17.601]  $ x: int [1:4] 0 1 2 3
[17:28:17.601]  - attr(*, "where")=List of 1
[17:28:17.601]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.601]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.601]  - attr(*, "resolved")= logi FALSE
[17:28:17.601]  - attr(*, "total_size")= num 64
[17:28:17.601]  - attr(*, "already-done")= logi TRUE
[17:28:17.604] - copied 'x' to environment
[17:28:17.605] assign_globals() ... done
[17:28:17.605] plan(): Setting new future strategy stack:
[17:28:17.605] List of future strategies:
[17:28:17.605] 1. sequential:
[17:28:17.605]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.605]    - tweaked: FALSE
[17:28:17.605]    - call: NULL
[17:28:17.606] plan(): nbrOfWorkers() = 1
[17:28:17.607] plan(): Setting new future strategy stack:
[17:28:17.607] List of future strategies:
[17:28:17.607] 1. sequential:
[17:28:17.607]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.607]    - tweaked: FALSE
[17:28:17.607]    - call: plan(strategy)
[17:28:17.608] plan(): nbrOfWorkers() = 1
[17:28:17.608] SequentialFuture started (and completed)
[17:28:17.608] - Launch lazy future ... done
[17:28:17.608] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-919933'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x00000266718940a0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.609] getGlobalsAndPackages() ...
[17:28:17.609] Searching for globals...
[17:28:17.611] - globals found: [3] '{', 'sample', 'x'
[17:28:17.611] Searching for globals ... DONE
[17:28:17.611] Resolving globals: FALSE
[17:28:17.611] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.612] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.612] - globals: [1] 'x'
[17:28:17.612] 
[17:28:17.612] getGlobalsAndPackages() ... DONE
[17:28:17.613] run() for 'Future' ...
[17:28:17.613] - state: 'created'
[17:28:17.613] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.613] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.614] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.614]   - Field: 'label'
[17:28:17.614]   - Field: 'local'
[17:28:17.614]   - Field: 'owner'
[17:28:17.614]   - Field: 'envir'
[17:28:17.614]   - Field: 'packages'
[17:28:17.615]   - Field: 'gc'
[17:28:17.615]   - Field: 'conditions'
[17:28:17.615]   - Field: 'expr'
[17:28:17.615]   - Field: 'uuid'
[17:28:17.615]   - Field: 'seed'
[17:28:17.616]   - Field: 'version'
[17:28:17.616]   - Field: 'result'
[17:28:17.616]   - Field: 'asynchronous'
[17:28:17.616]   - Field: 'calls'
[17:28:17.616]   - Field: 'globals'
[17:28:17.616]   - Field: 'stdout'
[17:28:17.617]   - Field: 'earlySignal'
[17:28:17.617]   - Field: 'lazy'
[17:28:17.617]   - Field: 'state'
[17:28:17.617] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.617] - Launch lazy future ...
[17:28:17.617] Packages needed by the future expression (n = 0): <none>
[17:28:17.618] Packages needed by future strategies (n = 0): <none>
[17:28:17.618] {
[17:28:17.618]     {
[17:28:17.618]         {
[17:28:17.618]             ...future.startTime <- base::Sys.time()
[17:28:17.618]             {
[17:28:17.618]                 {
[17:28:17.618]                   {
[17:28:17.618]                     base::local({
[17:28:17.618]                       has_future <- base::requireNamespace("future", 
[17:28:17.618]                         quietly = TRUE)
[17:28:17.618]                       if (has_future) {
[17:28:17.618]                         ns <- base::getNamespace("future")
[17:28:17.618]                         version <- ns[[".package"]][["version"]]
[17:28:17.618]                         if (is.null(version)) 
[17:28:17.618]                           version <- utils::packageVersion("future")
[17:28:17.618]                       }
[17:28:17.618]                       else {
[17:28:17.618]                         version <- NULL
[17:28:17.618]                       }
[17:28:17.618]                       if (!has_future || version < "1.8.0") {
[17:28:17.618]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.618]                           "", base::R.version$version.string), 
[17:28:17.618]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.618]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.618]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.618]                             "release", "version")], collapse = " "), 
[17:28:17.618]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.618]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.618]                           info)
[17:28:17.618]                         info <- base::paste(info, collapse = "; ")
[17:28:17.618]                         if (!has_future) {
[17:28:17.618]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.618]                             info)
[17:28:17.618]                         }
[17:28:17.618]                         else {
[17:28:17.618]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.618]                             info, version)
[17:28:17.618]                         }
[17:28:17.618]                         base::stop(msg)
[17:28:17.618]                       }
[17:28:17.618]                     })
[17:28:17.618]                   }
[17:28:17.618]                   ...future.strategy.old <- future::plan("list")
[17:28:17.618]                   options(future.plan = NULL)
[17:28:17.618]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.618]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.618]                 }
[17:28:17.618]                 ...future.workdir <- getwd()
[17:28:17.618]             }
[17:28:17.618]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.618]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.618]         }
[17:28:17.618]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.618]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.618]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.618]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.618]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.618]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.618]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.618]             base::names(...future.oldOptions))
[17:28:17.618]     }
[17:28:17.618]     if (FALSE) {
[17:28:17.618]     }
[17:28:17.618]     else {
[17:28:17.618]         if (TRUE) {
[17:28:17.618]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.618]                 open = "w")
[17:28:17.618]         }
[17:28:17.618]         else {
[17:28:17.618]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.618]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.618]         }
[17:28:17.618]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.618]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.618]             base::sink(type = "output", split = FALSE)
[17:28:17.618]             base::close(...future.stdout)
[17:28:17.618]         }, add = TRUE)
[17:28:17.618]     }
[17:28:17.618]     ...future.frame <- base::sys.nframe()
[17:28:17.618]     ...future.conditions <- base::list()
[17:28:17.618]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.618]     if (FALSE) {
[17:28:17.618]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.618]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.618]     }
[17:28:17.618]     ...future.result <- base::tryCatch({
[17:28:17.618]         base::withCallingHandlers({
[17:28:17.618]             ...future.value <- base::withVisible(base::local({
[17:28:17.618]                 sample(x, size = 1L)
[17:28:17.618]             }))
[17:28:17.618]             future::FutureResult(value = ...future.value$value, 
[17:28:17.618]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.618]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.618]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.618]                     ...future.globalenv.names))
[17:28:17.618]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.618]         }, condition = base::local({
[17:28:17.618]             c <- base::c
[17:28:17.618]             inherits <- base::inherits
[17:28:17.618]             invokeRestart <- base::invokeRestart
[17:28:17.618]             length <- base::length
[17:28:17.618]             list <- base::list
[17:28:17.618]             seq.int <- base::seq.int
[17:28:17.618]             signalCondition <- base::signalCondition
[17:28:17.618]             sys.calls <- base::sys.calls
[17:28:17.618]             `[[` <- base::`[[`
[17:28:17.618]             `+` <- base::`+`
[17:28:17.618]             `<<-` <- base::`<<-`
[17:28:17.618]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.618]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.618]                   3L)]
[17:28:17.618]             }
[17:28:17.618]             function(cond) {
[17:28:17.618]                 is_error <- inherits(cond, "error")
[17:28:17.618]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.618]                   NULL)
[17:28:17.618]                 if (is_error) {
[17:28:17.618]                   sessionInformation <- function() {
[17:28:17.618]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.618]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.618]                       search = base::search(), system = base::Sys.info())
[17:28:17.618]                   }
[17:28:17.618]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.618]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.618]                     cond$call), session = sessionInformation(), 
[17:28:17.618]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.618]                   signalCondition(cond)
[17:28:17.618]                 }
[17:28:17.618]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.618]                 "immediateCondition"))) {
[17:28:17.618]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.618]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.618]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.618]                   if (TRUE && !signal) {
[17:28:17.618]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.618]                     {
[17:28:17.618]                       inherits <- base::inherits
[17:28:17.618]                       invokeRestart <- base::invokeRestart
[17:28:17.618]                       is.null <- base::is.null
[17:28:17.618]                       muffled <- FALSE
[17:28:17.618]                       if (inherits(cond, "message")) {
[17:28:17.618]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.618]                         if (muffled) 
[17:28:17.618]                           invokeRestart("muffleMessage")
[17:28:17.618]                       }
[17:28:17.618]                       else if (inherits(cond, "warning")) {
[17:28:17.618]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.618]                         if (muffled) 
[17:28:17.618]                           invokeRestart("muffleWarning")
[17:28:17.618]                       }
[17:28:17.618]                       else if (inherits(cond, "condition")) {
[17:28:17.618]                         if (!is.null(pattern)) {
[17:28:17.618]                           computeRestarts <- base::computeRestarts
[17:28:17.618]                           grepl <- base::grepl
[17:28:17.618]                           restarts <- computeRestarts(cond)
[17:28:17.618]                           for (restart in restarts) {
[17:28:17.618]                             name <- restart$name
[17:28:17.618]                             if (is.null(name)) 
[17:28:17.618]                               next
[17:28:17.618]                             if (!grepl(pattern, name)) 
[17:28:17.618]                               next
[17:28:17.618]                             invokeRestart(restart)
[17:28:17.618]                             muffled <- TRUE
[17:28:17.618]                             break
[17:28:17.618]                           }
[17:28:17.618]                         }
[17:28:17.618]                       }
[17:28:17.618]                       invisible(muffled)
[17:28:17.618]                     }
[17:28:17.618]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.618]                   }
[17:28:17.618]                 }
[17:28:17.618]                 else {
[17:28:17.618]                   if (TRUE) {
[17:28:17.618]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.618]                     {
[17:28:17.618]                       inherits <- base::inherits
[17:28:17.618]                       invokeRestart <- base::invokeRestart
[17:28:17.618]                       is.null <- base::is.null
[17:28:17.618]                       muffled <- FALSE
[17:28:17.618]                       if (inherits(cond, "message")) {
[17:28:17.618]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.618]                         if (muffled) 
[17:28:17.618]                           invokeRestart("muffleMessage")
[17:28:17.618]                       }
[17:28:17.618]                       else if (inherits(cond, "warning")) {
[17:28:17.618]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.618]                         if (muffled) 
[17:28:17.618]                           invokeRestart("muffleWarning")
[17:28:17.618]                       }
[17:28:17.618]                       else if (inherits(cond, "condition")) {
[17:28:17.618]                         if (!is.null(pattern)) {
[17:28:17.618]                           computeRestarts <- base::computeRestarts
[17:28:17.618]                           grepl <- base::grepl
[17:28:17.618]                           restarts <- computeRestarts(cond)
[17:28:17.618]                           for (restart in restarts) {
[17:28:17.618]                             name <- restart$name
[17:28:17.618]                             if (is.null(name)) 
[17:28:17.618]                               next
[17:28:17.618]                             if (!grepl(pattern, name)) 
[17:28:17.618]                               next
[17:28:17.618]                             invokeRestart(restart)
[17:28:17.618]                             muffled <- TRUE
[17:28:17.618]                             break
[17:28:17.618]                           }
[17:28:17.618]                         }
[17:28:17.618]                       }
[17:28:17.618]                       invisible(muffled)
[17:28:17.618]                     }
[17:28:17.618]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.618]                   }
[17:28:17.618]                 }
[17:28:17.618]             }
[17:28:17.618]         }))
[17:28:17.618]     }, error = function(ex) {
[17:28:17.618]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.618]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.618]                 ...future.rng), started = ...future.startTime, 
[17:28:17.618]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.618]             version = "1.8"), class = "FutureResult")
[17:28:17.618]     }, finally = {
[17:28:17.618]         if (!identical(...future.workdir, getwd())) 
[17:28:17.618]             setwd(...future.workdir)
[17:28:17.618]         {
[17:28:17.618]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.618]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.618]             }
[17:28:17.618]             base::options(...future.oldOptions)
[17:28:17.618]             if (.Platform$OS.type == "windows") {
[17:28:17.618]                 old_names <- names(...future.oldEnvVars)
[17:28:17.618]                 envs <- base::Sys.getenv()
[17:28:17.618]                 names <- names(envs)
[17:28:17.618]                 common <- intersect(names, old_names)
[17:28:17.618]                 added <- setdiff(names, old_names)
[17:28:17.618]                 removed <- setdiff(old_names, names)
[17:28:17.618]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.618]                   envs[common]]
[17:28:17.618]                 NAMES <- toupper(changed)
[17:28:17.618]                 args <- list()
[17:28:17.618]                 for (kk in seq_along(NAMES)) {
[17:28:17.618]                   name <- changed[[kk]]
[17:28:17.618]                   NAME <- NAMES[[kk]]
[17:28:17.618]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.618]                     next
[17:28:17.618]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.618]                 }
[17:28:17.618]                 NAMES <- toupper(added)
[17:28:17.618]                 for (kk in seq_along(NAMES)) {
[17:28:17.618]                   name <- added[[kk]]
[17:28:17.618]                   NAME <- NAMES[[kk]]
[17:28:17.618]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.618]                     next
[17:28:17.618]                   args[[name]] <- ""
[17:28:17.618]                 }
[17:28:17.618]                 NAMES <- toupper(removed)
[17:28:17.618]                 for (kk in seq_along(NAMES)) {
[17:28:17.618]                   name <- removed[[kk]]
[17:28:17.618]                   NAME <- NAMES[[kk]]
[17:28:17.618]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.618]                     next
[17:28:17.618]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.618]                 }
[17:28:17.618]                 if (length(args) > 0) 
[17:28:17.618]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.618]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.618]             }
[17:28:17.618]             else {
[17:28:17.618]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.618]             }
[17:28:17.618]             {
[17:28:17.618]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.618]                   0L) {
[17:28:17.618]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.618]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.618]                   base::options(opts)
[17:28:17.618]                 }
[17:28:17.618]                 {
[17:28:17.618]                   {
[17:28:17.618]                     base::assign(".Random.seed", c(10407L, 866756367L, 
[17:28:17.618]                     -417401399L, 1578556647L, 707627690L, 642855454L, 
[17:28:17.618]                     -1203128252L), envir = base::globalenv(), 
[17:28:17.618]                       inherits = FALSE)
[17:28:17.618]                     NULL
[17:28:17.618]                   }
[17:28:17.618]                   options(future.plan = NULL)
[17:28:17.618]                   if (is.na(NA_character_)) 
[17:28:17.618]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.618]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.618]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.618]                     .init = FALSE)
[17:28:17.618]                 }
[17:28:17.618]             }
[17:28:17.618]         }
[17:28:17.618]     })
[17:28:17.618]     if (TRUE) {
[17:28:17.618]         base::sink(type = "output", split = FALSE)
[17:28:17.618]         if (TRUE) {
[17:28:17.618]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.618]         }
[17:28:17.618]         else {
[17:28:17.618]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.618]         }
[17:28:17.618]         base::close(...future.stdout)
[17:28:17.618]         ...future.stdout <- NULL
[17:28:17.618]     }
[17:28:17.618]     ...future.result$conditions <- ...future.conditions
[17:28:17.618]     ...future.result$finished <- base::Sys.time()
[17:28:17.618]     ...future.result
[17:28:17.618] }
[17:28:17.622] assign_globals() ...
[17:28:17.622] List of 1
[17:28:17.622]  $ x: int [1:4] 0 1 2 3
[17:28:17.622]  - attr(*, "where")=List of 1
[17:28:17.622]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.622]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.622]  - attr(*, "resolved")= logi FALSE
[17:28:17.622]  - attr(*, "total_size")= num 64
[17:28:17.622]  - attr(*, "already-done")= logi TRUE
[17:28:17.625] - copied 'x' to environment
[17:28:17.625] assign_globals() ... done
[17:28:17.625] plan(): Setting new future strategy stack:
[17:28:17.626] List of future strategies:
[17:28:17.626] 1. sequential:
[17:28:17.626]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.626]    - tweaked: FALSE
[17:28:17.626]    - call: NULL
[17:28:17.626] plan(): nbrOfWorkers() = 1
[17:28:17.627] plan(): Setting new future strategy stack:
[17:28:17.627] List of future strategies:
[17:28:17.627] 1. sequential:
[17:28:17.627]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.627]    - tweaked: FALSE
[17:28:17.627]    - call: plan(strategy)
[17:28:17.628] plan(): nbrOfWorkers() = 1
[17:28:17.628] SequentialFuture started (and completed)
[17:28:17.629] - Launch lazy future ... done
[17:28:17.629] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-894414'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x00000266718940a0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.630] getGlobalsAndPackages() ...
[17:28:17.630] Searching for globals...
[17:28:17.631] - globals found: [3] '{', 'sample', 'x'
[17:28:17.631] Searching for globals ... DONE
[17:28:17.631] Resolving globals: FALSE
[17:28:17.633] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.633] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.633] - globals: [1] 'x'
[17:28:17.633] 
[17:28:17.634] getGlobalsAndPackages() ... DONE
[17:28:17.634] run() for 'Future' ...
[17:28:17.634] - state: 'created'
[17:28:17.634] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.635] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.635] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.635]   - Field: 'label'
[17:28:17.635]   - Field: 'local'
[17:28:17.635]   - Field: 'owner'
[17:28:17.636]   - Field: 'envir'
[17:28:17.636]   - Field: 'packages'
[17:28:17.636]   - Field: 'gc'
[17:28:17.636]   - Field: 'conditions'
[17:28:17.636]   - Field: 'expr'
[17:28:17.636]   - Field: 'uuid'
[17:28:17.637]   - Field: 'seed'
[17:28:17.637]   - Field: 'version'
[17:28:17.637]   - Field: 'result'
[17:28:17.637]   - Field: 'asynchronous'
[17:28:17.637]   - Field: 'calls'
[17:28:17.638]   - Field: 'globals'
[17:28:17.638]   - Field: 'stdout'
[17:28:17.638]   - Field: 'earlySignal'
[17:28:17.638]   - Field: 'lazy'
[17:28:17.638]   - Field: 'state'
[17:28:17.638] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.639] - Launch lazy future ...
[17:28:17.639] Packages needed by the future expression (n = 0): <none>
[17:28:17.639] Packages needed by future strategies (n = 0): <none>
[17:28:17.639] {
[17:28:17.639]     {
[17:28:17.639]         {
[17:28:17.639]             ...future.startTime <- base::Sys.time()
[17:28:17.639]             {
[17:28:17.639]                 {
[17:28:17.639]                   {
[17:28:17.639]                     base::local({
[17:28:17.639]                       has_future <- base::requireNamespace("future", 
[17:28:17.639]                         quietly = TRUE)
[17:28:17.639]                       if (has_future) {
[17:28:17.639]                         ns <- base::getNamespace("future")
[17:28:17.639]                         version <- ns[[".package"]][["version"]]
[17:28:17.639]                         if (is.null(version)) 
[17:28:17.639]                           version <- utils::packageVersion("future")
[17:28:17.639]                       }
[17:28:17.639]                       else {
[17:28:17.639]                         version <- NULL
[17:28:17.639]                       }
[17:28:17.639]                       if (!has_future || version < "1.8.0") {
[17:28:17.639]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.639]                           "", base::R.version$version.string), 
[17:28:17.639]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.639]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.639]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.639]                             "release", "version")], collapse = " "), 
[17:28:17.639]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.639]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.639]                           info)
[17:28:17.639]                         info <- base::paste(info, collapse = "; ")
[17:28:17.639]                         if (!has_future) {
[17:28:17.639]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.639]                             info)
[17:28:17.639]                         }
[17:28:17.639]                         else {
[17:28:17.639]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.639]                             info, version)
[17:28:17.639]                         }
[17:28:17.639]                         base::stop(msg)
[17:28:17.639]                       }
[17:28:17.639]                     })
[17:28:17.639]                   }
[17:28:17.639]                   ...future.strategy.old <- future::plan("list")
[17:28:17.639]                   options(future.plan = NULL)
[17:28:17.639]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.639]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.639]                 }
[17:28:17.639]                 ...future.workdir <- getwd()
[17:28:17.639]             }
[17:28:17.639]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.639]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.639]         }
[17:28:17.639]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.639]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.639]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.639]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.639]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.639]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.639]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.639]             base::names(...future.oldOptions))
[17:28:17.639]     }
[17:28:17.639]     if (FALSE) {
[17:28:17.639]     }
[17:28:17.639]     else {
[17:28:17.639]         if (TRUE) {
[17:28:17.639]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.639]                 open = "w")
[17:28:17.639]         }
[17:28:17.639]         else {
[17:28:17.639]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.639]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.639]         }
[17:28:17.639]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.639]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.639]             base::sink(type = "output", split = FALSE)
[17:28:17.639]             base::close(...future.stdout)
[17:28:17.639]         }, add = TRUE)
[17:28:17.639]     }
[17:28:17.639]     ...future.frame <- base::sys.nframe()
[17:28:17.639]     ...future.conditions <- base::list()
[17:28:17.639]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.639]     if (FALSE) {
[17:28:17.639]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.639]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.639]     }
[17:28:17.639]     ...future.result <- base::tryCatch({
[17:28:17.639]         base::withCallingHandlers({
[17:28:17.639]             ...future.value <- base::withVisible(base::local({
[17:28:17.639]                 sample(x, size = 1L)
[17:28:17.639]             }))
[17:28:17.639]             future::FutureResult(value = ...future.value$value, 
[17:28:17.639]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.639]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.639]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.639]                     ...future.globalenv.names))
[17:28:17.639]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.639]         }, condition = base::local({
[17:28:17.639]             c <- base::c
[17:28:17.639]             inherits <- base::inherits
[17:28:17.639]             invokeRestart <- base::invokeRestart
[17:28:17.639]             length <- base::length
[17:28:17.639]             list <- base::list
[17:28:17.639]             seq.int <- base::seq.int
[17:28:17.639]             signalCondition <- base::signalCondition
[17:28:17.639]             sys.calls <- base::sys.calls
[17:28:17.639]             `[[` <- base::`[[`
[17:28:17.639]             `+` <- base::`+`
[17:28:17.639]             `<<-` <- base::`<<-`
[17:28:17.639]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.639]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.639]                   3L)]
[17:28:17.639]             }
[17:28:17.639]             function(cond) {
[17:28:17.639]                 is_error <- inherits(cond, "error")
[17:28:17.639]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.639]                   NULL)
[17:28:17.639]                 if (is_error) {
[17:28:17.639]                   sessionInformation <- function() {
[17:28:17.639]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.639]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.639]                       search = base::search(), system = base::Sys.info())
[17:28:17.639]                   }
[17:28:17.639]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.639]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.639]                     cond$call), session = sessionInformation(), 
[17:28:17.639]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.639]                   signalCondition(cond)
[17:28:17.639]                 }
[17:28:17.639]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.639]                 "immediateCondition"))) {
[17:28:17.639]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.639]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.639]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.639]                   if (TRUE && !signal) {
[17:28:17.639]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.639]                     {
[17:28:17.639]                       inherits <- base::inherits
[17:28:17.639]                       invokeRestart <- base::invokeRestart
[17:28:17.639]                       is.null <- base::is.null
[17:28:17.639]                       muffled <- FALSE
[17:28:17.639]                       if (inherits(cond, "message")) {
[17:28:17.639]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.639]                         if (muffled) 
[17:28:17.639]                           invokeRestart("muffleMessage")
[17:28:17.639]                       }
[17:28:17.639]                       else if (inherits(cond, "warning")) {
[17:28:17.639]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.639]                         if (muffled) 
[17:28:17.639]                           invokeRestart("muffleWarning")
[17:28:17.639]                       }
[17:28:17.639]                       else if (inherits(cond, "condition")) {
[17:28:17.639]                         if (!is.null(pattern)) {
[17:28:17.639]                           computeRestarts <- base::computeRestarts
[17:28:17.639]                           grepl <- base::grepl
[17:28:17.639]                           restarts <- computeRestarts(cond)
[17:28:17.639]                           for (restart in restarts) {
[17:28:17.639]                             name <- restart$name
[17:28:17.639]                             if (is.null(name)) 
[17:28:17.639]                               next
[17:28:17.639]                             if (!grepl(pattern, name)) 
[17:28:17.639]                               next
[17:28:17.639]                             invokeRestart(restart)
[17:28:17.639]                             muffled <- TRUE
[17:28:17.639]                             break
[17:28:17.639]                           }
[17:28:17.639]                         }
[17:28:17.639]                       }
[17:28:17.639]                       invisible(muffled)
[17:28:17.639]                     }
[17:28:17.639]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.639]                   }
[17:28:17.639]                 }
[17:28:17.639]                 else {
[17:28:17.639]                   if (TRUE) {
[17:28:17.639]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.639]                     {
[17:28:17.639]                       inherits <- base::inherits
[17:28:17.639]                       invokeRestart <- base::invokeRestart
[17:28:17.639]                       is.null <- base::is.null
[17:28:17.639]                       muffled <- FALSE
[17:28:17.639]                       if (inherits(cond, "message")) {
[17:28:17.639]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.639]                         if (muffled) 
[17:28:17.639]                           invokeRestart("muffleMessage")
[17:28:17.639]                       }
[17:28:17.639]                       else if (inherits(cond, "warning")) {
[17:28:17.639]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.639]                         if (muffled) 
[17:28:17.639]                           invokeRestart("muffleWarning")
[17:28:17.639]                       }
[17:28:17.639]                       else if (inherits(cond, "condition")) {
[17:28:17.639]                         if (!is.null(pattern)) {
[17:28:17.639]                           computeRestarts <- base::computeRestarts
[17:28:17.639]                           grepl <- base::grepl
[17:28:17.639]                           restarts <- computeRestarts(cond)
[17:28:17.639]                           for (restart in restarts) {
[17:28:17.639]                             name <- restart$name
[17:28:17.639]                             if (is.null(name)) 
[17:28:17.639]                               next
[17:28:17.639]                             if (!grepl(pattern, name)) 
[17:28:17.639]                               next
[17:28:17.639]                             invokeRestart(restart)
[17:28:17.639]                             muffled <- TRUE
[17:28:17.639]                             break
[17:28:17.639]                           }
[17:28:17.639]                         }
[17:28:17.639]                       }
[17:28:17.639]                       invisible(muffled)
[17:28:17.639]                     }
[17:28:17.639]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.639]                   }
[17:28:17.639]                 }
[17:28:17.639]             }
[17:28:17.639]         }))
[17:28:17.639]     }, error = function(ex) {
[17:28:17.639]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.639]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.639]                 ...future.rng), started = ...future.startTime, 
[17:28:17.639]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.639]             version = "1.8"), class = "FutureResult")
[17:28:17.639]     }, finally = {
[17:28:17.639]         if (!identical(...future.workdir, getwd())) 
[17:28:17.639]             setwd(...future.workdir)
[17:28:17.639]         {
[17:28:17.639]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.639]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.639]             }
[17:28:17.639]             base::options(...future.oldOptions)
[17:28:17.639]             if (.Platform$OS.type == "windows") {
[17:28:17.639]                 old_names <- names(...future.oldEnvVars)
[17:28:17.639]                 envs <- base::Sys.getenv()
[17:28:17.639]                 names <- names(envs)
[17:28:17.639]                 common <- intersect(names, old_names)
[17:28:17.639]                 added <- setdiff(names, old_names)
[17:28:17.639]                 removed <- setdiff(old_names, names)
[17:28:17.639]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.639]                   envs[common]]
[17:28:17.639]                 NAMES <- toupper(changed)
[17:28:17.639]                 args <- list()
[17:28:17.639]                 for (kk in seq_along(NAMES)) {
[17:28:17.639]                   name <- changed[[kk]]
[17:28:17.639]                   NAME <- NAMES[[kk]]
[17:28:17.639]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.639]                     next
[17:28:17.639]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.639]                 }
[17:28:17.639]                 NAMES <- toupper(added)
[17:28:17.639]                 for (kk in seq_along(NAMES)) {
[17:28:17.639]                   name <- added[[kk]]
[17:28:17.639]                   NAME <- NAMES[[kk]]
[17:28:17.639]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.639]                     next
[17:28:17.639]                   args[[name]] <- ""
[17:28:17.639]                 }
[17:28:17.639]                 NAMES <- toupper(removed)
[17:28:17.639]                 for (kk in seq_along(NAMES)) {
[17:28:17.639]                   name <- removed[[kk]]
[17:28:17.639]                   NAME <- NAMES[[kk]]
[17:28:17.639]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.639]                     next
[17:28:17.639]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.639]                 }
[17:28:17.639]                 if (length(args) > 0) 
[17:28:17.639]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.639]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.639]             }
[17:28:17.639]             else {
[17:28:17.639]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.639]             }
[17:28:17.639]             {
[17:28:17.639]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.639]                   0L) {
[17:28:17.639]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.639]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.639]                   base::options(opts)
[17:28:17.639]                 }
[17:28:17.639]                 {
[17:28:17.639]                   {
[17:28:17.639]                     base::assign(".Random.seed", c(10407L, 1578556647L, 
[17:28:17.639]                     -772592193L, 1422475508L, -1203128252L, -1085515778L, 
[17:28:17.639]                     -1077665960L), envir = base::globalenv(), 
[17:28:17.639]                       inherits = FALSE)
[17:28:17.639]                     NULL
[17:28:17.639]                   }
[17:28:17.639]                   options(future.plan = NULL)
[17:28:17.639]                   if (is.na(NA_character_)) 
[17:28:17.639]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.639]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.639]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.639]                     .init = FALSE)
[17:28:17.639]                 }
[17:28:17.639]             }
[17:28:17.639]         }
[17:28:17.639]     })
[17:28:17.639]     if (TRUE) {
[17:28:17.639]         base::sink(type = "output", split = FALSE)
[17:28:17.639]         if (TRUE) {
[17:28:17.639]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.639]         }
[17:28:17.639]         else {
[17:28:17.639]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.639]         }
[17:28:17.639]         base::close(...future.stdout)
[17:28:17.639]         ...future.stdout <- NULL
[17:28:17.639]     }
[17:28:17.639]     ...future.result$conditions <- ...future.conditions
[17:28:17.639]     ...future.result$finished <- base::Sys.time()
[17:28:17.639]     ...future.result
[17:28:17.639] }
[17:28:17.643] assign_globals() ...
[17:28:17.643] List of 1
[17:28:17.643]  $ x: int [1:4] 0 1 2 3
[17:28:17.643]  - attr(*, "where")=List of 1
[17:28:17.643]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.643]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.643]  - attr(*, "resolved")= logi FALSE
[17:28:17.643]  - attr(*, "total_size")= num 64
[17:28:17.643]  - attr(*, "already-done")= logi TRUE
[17:28:17.646] - copied 'x' to environment
[17:28:17.647] assign_globals() ... done
[17:28:17.647] plan(): Setting new future strategy stack:
[17:28:17.647] List of future strategies:
[17:28:17.647] 1. sequential:
[17:28:17.647]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.647]    - tweaked: FALSE
[17:28:17.647]    - call: NULL
[17:28:17.648] plan(): nbrOfWorkers() = 1
[17:28:17.649] plan(): Setting new future strategy stack:
[17:28:17.649] List of future strategies:
[17:28:17.649] 1. sequential:
[17:28:17.649]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.649]    - tweaked: FALSE
[17:28:17.649]    - call: plan(strategy)
[17:28:17.650] plan(): nbrOfWorkers() = 1
[17:28:17.650] SequentialFuture started (and completed)
[17:28:17.650] - Launch lazy future ... done
[17:28:17.650] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-431366'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x00000266718940a0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.651] resolve() on list ...
[17:28:17.651]  recursive: 0
[17:28:17.652]  length: 4
[17:28:17.652] 
[17:28:17.652] resolved() for 'SequentialFuture' ...
[17:28:17.652] - state: 'finished'
[17:28:17.652] - run: TRUE
[17:28:17.652] - result: 'FutureResult'
[17:28:17.653] resolved() for 'SequentialFuture' ... done
[17:28:17.653] Future #1
[17:28:17.653] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:28:17.653] - nx: 4
[17:28:17.654] - relay: TRUE
[17:28:17.654] - stdout: TRUE
[17:28:17.654] - signal: TRUE
[17:28:17.654] - resignal: FALSE
[17:28:17.654] - force: TRUE
[17:28:17.654] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.655] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.655]  - until=1
[17:28:17.655]  - relaying element #1
[17:28:17.655] signalConditions() ...
[17:28:17.655]  - include = 'immediateCondition'
[17:28:17.655]  - exclude = 
[17:28:17.656]  - resignal = FALSE
[17:28:17.656]  - Number of conditions: 1
[17:28:17.656] signalConditions() ... done
[17:28:17.656] signalConditions() ...
[17:28:17.656]  - include = 'immediateCondition'
[17:28:17.656]  - exclude = 
[17:28:17.657]  - resignal = FALSE
[17:28:17.657]  - Number of conditions: 1
[17:28:17.657] signalConditions() ... done
[17:28:17.657] signalConditions() ...
[17:28:17.657]  - include = 'condition'
[17:28:17.657]  - exclude = 'immediateCondition'
[17:28:17.658]  - resignal = TRUE
[17:28:17.658]  - Number of conditions: 1
[17:28:17.658]  - Condition #1: 'RngFutureWarning', 'FutureWarning', 'warning', 'RngFutureCondition', 'FutureCondition', 'condition'
[17:28:17.658] signalConditions() ... done
[17:28:17.658] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.658] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.659] signalConditionsASAP(SequentialFuture, pos=1) ... done
<RngFutureWarning: UNRELIABLE VALUE: Future ('fsample_1-163723') 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: 01fa5cf1-499a-13be-8571-91db0def47d2


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

DEBUG: END TROUBLESHOOTING HELP
[17:28:17.660] getGlobalsAndPackages() ...
[17:28:17.660] Searching for globals...
[17:28:17.661] - globals found: [3] '{', 'sample', 'x'
[17:28:17.661] Searching for globals ... DONE
[17:28:17.662] Resolving globals: FALSE
[17:28:17.662] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.662] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.663] - globals: [1] 'x'
[17:28:17.663] 
[17:28:17.663] getGlobalsAndPackages() ... DONE
[17:28:17.663] run() for 'Future' ...
[17:28:17.663] - state: 'created'
[17:28:17.664] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.664] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.664] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.664]   - Field: 'label'
[17:28:17.665]   - Field: 'local'
[17:28:17.665]   - Field: 'owner'
[17:28:17.665]   - Field: 'envir'
[17:28:17.665]   - Field: 'packages'
[17:28:17.665]   - Field: 'gc'
[17:28:17.665]   - Field: 'conditions'
[17:28:17.666]   - Field: 'expr'
[17:28:17.666]   - Field: 'uuid'
[17:28:17.666]   - Field: 'seed'
[17:28:17.666]   - Field: 'version'
[17:28:17.666]   - Field: 'result'
[17:28:17.666]   - Field: 'asynchronous'
[17:28:17.667]   - Field: 'calls'
[17:28:17.667]   - Field: 'globals'
[17:28:17.667]   - Field: 'stdout'
[17:28:17.667]   - Field: 'earlySignal'
[17:28:17.668]   - Field: 'lazy'
[17:28:17.668]   - Field: 'state'
[17:28:17.668] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.669] - Launch lazy future ...
[17:28:17.669] Packages needed by the future expression (n = 0): <none>
[17:28:17.669] Packages needed by future strategies (n = 0): <none>
[17:28:17.670] {
[17:28:17.670]     {
[17:28:17.670]         {
[17:28:17.670]             ...future.startTime <- base::Sys.time()
[17:28:17.670]             {
[17:28:17.670]                 {
[17:28:17.670]                   {
[17:28:17.670]                     base::local({
[17:28:17.670]                       has_future <- base::requireNamespace("future", 
[17:28:17.670]                         quietly = TRUE)
[17:28:17.670]                       if (has_future) {
[17:28:17.670]                         ns <- base::getNamespace("future")
[17:28:17.670]                         version <- ns[[".package"]][["version"]]
[17:28:17.670]                         if (is.null(version)) 
[17:28:17.670]                           version <- utils::packageVersion("future")
[17:28:17.670]                       }
[17:28:17.670]                       else {
[17:28:17.670]                         version <- NULL
[17:28:17.670]                       }
[17:28:17.670]                       if (!has_future || version < "1.8.0") {
[17:28:17.670]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.670]                           "", base::R.version$version.string), 
[17:28:17.670]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.670]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.670]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.670]                             "release", "version")], collapse = " "), 
[17:28:17.670]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.670]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.670]                           info)
[17:28:17.670]                         info <- base::paste(info, collapse = "; ")
[17:28:17.670]                         if (!has_future) {
[17:28:17.670]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.670]                             info)
[17:28:17.670]                         }
[17:28:17.670]                         else {
[17:28:17.670]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.670]                             info, version)
[17:28:17.670]                         }
[17:28:17.670]                         base::stop(msg)
[17:28:17.670]                       }
[17:28:17.670]                     })
[17:28:17.670]                   }
[17:28:17.670]                   ...future.strategy.old <- future::plan("list")
[17:28:17.670]                   options(future.plan = NULL)
[17:28:17.670]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.670]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.670]                 }
[17:28:17.670]                 ...future.workdir <- getwd()
[17:28:17.670]             }
[17:28:17.670]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.670]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.670]         }
[17:28:17.670]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.670]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.670]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.670]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.670]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.670]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.670]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.670]             base::names(...future.oldOptions))
[17:28:17.670]     }
[17:28:17.670]     if (FALSE) {
[17:28:17.670]     }
[17:28:17.670]     else {
[17:28:17.670]         if (TRUE) {
[17:28:17.670]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.670]                 open = "w")
[17:28:17.670]         }
[17:28:17.670]         else {
[17:28:17.670]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.670]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.670]         }
[17:28:17.670]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.670]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.670]             base::sink(type = "output", split = FALSE)
[17:28:17.670]             base::close(...future.stdout)
[17:28:17.670]         }, add = TRUE)
[17:28:17.670]     }
[17:28:17.670]     ...future.frame <- base::sys.nframe()
[17:28:17.670]     ...future.conditions <- base::list()
[17:28:17.670]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.670]     if (FALSE) {
[17:28:17.670]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.670]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.670]     }
[17:28:17.670]     ...future.result <- base::tryCatch({
[17:28:17.670]         base::withCallingHandlers({
[17:28:17.670]             ...future.value <- base::withVisible(base::local({
[17:28:17.670]                 sample(x, size = 1L)
[17:28:17.670]             }))
[17:28:17.670]             future::FutureResult(value = ...future.value$value, 
[17:28:17.670]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.670]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.670]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.670]                     ...future.globalenv.names))
[17:28:17.670]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.670]         }, condition = base::local({
[17:28:17.670]             c <- base::c
[17:28:17.670]             inherits <- base::inherits
[17:28:17.670]             invokeRestart <- base::invokeRestart
[17:28:17.670]             length <- base::length
[17:28:17.670]             list <- base::list
[17:28:17.670]             seq.int <- base::seq.int
[17:28:17.670]             signalCondition <- base::signalCondition
[17:28:17.670]             sys.calls <- base::sys.calls
[17:28:17.670]             `[[` <- base::`[[`
[17:28:17.670]             `+` <- base::`+`
[17:28:17.670]             `<<-` <- base::`<<-`
[17:28:17.670]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.670]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.670]                   3L)]
[17:28:17.670]             }
[17:28:17.670]             function(cond) {
[17:28:17.670]                 is_error <- inherits(cond, "error")
[17:28:17.670]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.670]                   NULL)
[17:28:17.670]                 if (is_error) {
[17:28:17.670]                   sessionInformation <- function() {
[17:28:17.670]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.670]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.670]                       search = base::search(), system = base::Sys.info())
[17:28:17.670]                   }
[17:28:17.670]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.670]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.670]                     cond$call), session = sessionInformation(), 
[17:28:17.670]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.670]                   signalCondition(cond)
[17:28:17.670]                 }
[17:28:17.670]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.670]                 "immediateCondition"))) {
[17:28:17.670]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.670]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.670]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.670]                   if (TRUE && !signal) {
[17:28:17.670]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.670]                     {
[17:28:17.670]                       inherits <- base::inherits
[17:28:17.670]                       invokeRestart <- base::invokeRestart
[17:28:17.670]                       is.null <- base::is.null
[17:28:17.670]                       muffled <- FALSE
[17:28:17.670]                       if (inherits(cond, "message")) {
[17:28:17.670]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.670]                         if (muffled) 
[17:28:17.670]                           invokeRestart("muffleMessage")
[17:28:17.670]                       }
[17:28:17.670]                       else if (inherits(cond, "warning")) {
[17:28:17.670]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.670]                         if (muffled) 
[17:28:17.670]                           invokeRestart("muffleWarning")
[17:28:17.670]                       }
[17:28:17.670]                       else if (inherits(cond, "condition")) {
[17:28:17.670]                         if (!is.null(pattern)) {
[17:28:17.670]                           computeRestarts <- base::computeRestarts
[17:28:17.670]                           grepl <- base::grepl
[17:28:17.670]                           restarts <- computeRestarts(cond)
[17:28:17.670]                           for (restart in restarts) {
[17:28:17.670]                             name <- restart$name
[17:28:17.670]                             if (is.null(name)) 
[17:28:17.670]                               next
[17:28:17.670]                             if (!grepl(pattern, name)) 
[17:28:17.670]                               next
[17:28:17.670]                             invokeRestart(restart)
[17:28:17.670]                             muffled <- TRUE
[17:28:17.670]                             break
[17:28:17.670]                           }
[17:28:17.670]                         }
[17:28:17.670]                       }
[17:28:17.670]                       invisible(muffled)
[17:28:17.670]                     }
[17:28:17.670]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.670]                   }
[17:28:17.670]                 }
[17:28:17.670]                 else {
[17:28:17.670]                   if (TRUE) {
[17:28:17.670]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.670]                     {
[17:28:17.670]                       inherits <- base::inherits
[17:28:17.670]                       invokeRestart <- base::invokeRestart
[17:28:17.670]                       is.null <- base::is.null
[17:28:17.670]                       muffled <- FALSE
[17:28:17.670]                       if (inherits(cond, "message")) {
[17:28:17.670]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.670]                         if (muffled) 
[17:28:17.670]                           invokeRestart("muffleMessage")
[17:28:17.670]                       }
[17:28:17.670]                       else if (inherits(cond, "warning")) {
[17:28:17.670]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.670]                         if (muffled) 
[17:28:17.670]                           invokeRestart("muffleWarning")
[17:28:17.670]                       }
[17:28:17.670]                       else if (inherits(cond, "condition")) {
[17:28:17.670]                         if (!is.null(pattern)) {
[17:28:17.670]                           computeRestarts <- base::computeRestarts
[17:28:17.670]                           grepl <- base::grepl
[17:28:17.670]                           restarts <- computeRestarts(cond)
[17:28:17.670]                           for (restart in restarts) {
[17:28:17.670]                             name <- restart$name
[17:28:17.670]                             if (is.null(name)) 
[17:28:17.670]                               next
[17:28:17.670]                             if (!grepl(pattern, name)) 
[17:28:17.670]                               next
[17:28:17.670]                             invokeRestart(restart)
[17:28:17.670]                             muffled <- TRUE
[17:28:17.670]                             break
[17:28:17.670]                           }
[17:28:17.670]                         }
[17:28:17.670]                       }
[17:28:17.670]                       invisible(muffled)
[17:28:17.670]                     }
[17:28:17.670]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.670]                   }
[17:28:17.670]                 }
[17:28:17.670]             }
[17:28:17.670]         }))
[17:28:17.670]     }, error = function(ex) {
[17:28:17.670]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.670]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.670]                 ...future.rng), started = ...future.startTime, 
[17:28:17.670]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.670]             version = "1.8"), class = "FutureResult")
[17:28:17.670]     }, finally = {
[17:28:17.670]         if (!identical(...future.workdir, getwd())) 
[17:28:17.670]             setwd(...future.workdir)
[17:28:17.670]         {
[17:28:17.670]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.670]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.670]             }
[17:28:17.670]             base::options(...future.oldOptions)
[17:28:17.670]             if (.Platform$OS.type == "windows") {
[17:28:17.670]                 old_names <- names(...future.oldEnvVars)
[17:28:17.670]                 envs <- base::Sys.getenv()
[17:28:17.670]                 names <- names(envs)
[17:28:17.670]                 common <- intersect(names, old_names)
[17:28:17.670]                 added <- setdiff(names, old_names)
[17:28:17.670]                 removed <- setdiff(old_names, names)
[17:28:17.670]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.670]                   envs[common]]
[17:28:17.670]                 NAMES <- toupper(changed)
[17:28:17.670]                 args <- list()
[17:28:17.670]                 for (kk in seq_along(NAMES)) {
[17:28:17.670]                   name <- changed[[kk]]
[17:28:17.670]                   NAME <- NAMES[[kk]]
[17:28:17.670]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.670]                     next
[17:28:17.670]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.670]                 }
[17:28:17.670]                 NAMES <- toupper(added)
[17:28:17.670]                 for (kk in seq_along(NAMES)) {
[17:28:17.670]                   name <- added[[kk]]
[17:28:17.670]                   NAME <- NAMES[[kk]]
[17:28:17.670]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.670]                     next
[17:28:17.670]                   args[[name]] <- ""
[17:28:17.670]                 }
[17:28:17.670]                 NAMES <- toupper(removed)
[17:28:17.670]                 for (kk in seq_along(NAMES)) {
[17:28:17.670]                   name <- removed[[kk]]
[17:28:17.670]                   NAME <- NAMES[[kk]]
[17:28:17.670]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.670]                     next
[17:28:17.670]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.670]                 }
[17:28:17.670]                 if (length(args) > 0) 
[17:28:17.670]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.670]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.670]             }
[17:28:17.670]             else {
[17:28:17.670]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.670]             }
[17:28:17.670]             {
[17:28:17.670]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.670]                   0L) {
[17:28:17.670]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.670]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.670]                   base::options(opts)
[17:28:17.670]                 }
[17:28:17.670]                 {
[17:28:17.670]                   {
[17:28:17.670]                     base::assign(".Random.seed", c(10407L, -1559578278L, 
[17:28:17.670]                     710902500L, -844755408L, 1082501593L, -1770190531L, 
[17:28:17.670]                     1407237460L), envir = base::globalenv(), 
[17:28:17.670]                       inherits = FALSE)
[17:28:17.670]                     NULL
[17:28:17.670]                   }
[17:28:17.670]                   options(future.plan = NULL)
[17:28:17.670]                   if (is.na(NA_character_)) 
[17:28:17.670]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.670]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.670]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.670]                     .init = FALSE)
[17:28:17.670]                 }
[17:28:17.670]             }
[17:28:17.670]         }
[17:28:17.670]     })
[17:28:17.670]     if (TRUE) {
[17:28:17.670]         base::sink(type = "output", split = FALSE)
[17:28:17.670]         if (TRUE) {
[17:28:17.670]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.670]         }
[17:28:17.670]         else {
[17:28:17.670]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.670]         }
[17:28:17.670]         base::close(...future.stdout)
[17:28:17.670]         ...future.stdout <- NULL
[17:28:17.670]     }
[17:28:17.670]     ...future.result$conditions <- ...future.conditions
[17:28:17.670]     ...future.result$finished <- base::Sys.time()
[17:28:17.670]     ...future.result
[17:28:17.670] }
[17:28:17.673] assign_globals() ...
[17:28:17.674] List of 1
[17:28:17.674]  $ x: int [1:4] 0 1 2 3
[17:28:17.674]  - attr(*, "where")=List of 1
[17:28:17.674]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.674]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.674]  - attr(*, "resolved")= logi FALSE
[17:28:17.674]  - attr(*, "total_size")= num 64
[17:28:17.674]  - attr(*, "already-done")= logi TRUE
[17:28:17.677] - copied 'x' to environment
[17:28:17.677] assign_globals() ... done
[17:28:17.677] plan(): Setting new future strategy stack:
[17:28:17.677] List of future strategies:
[17:28:17.677] 1. sequential:
[17:28:17.677]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.677]    - tweaked: FALSE
[17:28:17.677]    - call: NULL
[17:28:17.678] plan(): nbrOfWorkers() = 1
[17:28:17.679] plan(): Setting new future strategy stack:
[17:28:17.679] List of future strategies:
[17:28:17.679] 1. sequential:
[17:28:17.679]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.679]    - tweaked: FALSE
[17:28:17.679]    - call: plan(strategy)
[17:28:17.680] plan(): nbrOfWorkers() = 1
[17:28:17.680] SequentialFuture started (and completed)
[17:28:17.680] - Launch lazy future ... done
[17:28:17.680] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-162246'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x0000026673a91d80
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.681] getGlobalsAndPackages() ...
[17:28:17.682] Searching for globals...
[17:28:17.683] - globals found: [3] '{', 'sample', 'x'
[17:28:17.683] Searching for globals ... DONE
[17:28:17.683] Resolving globals: FALSE
[17:28:17.684] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.684] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.684] - globals: [1] 'x'
[17:28:17.684] 
[17:28:17.684] getGlobalsAndPackages() ... DONE
[17:28:17.685] run() for 'Future' ...
[17:28:17.685] - state: 'created'
[17:28:17.685] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.686] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.686] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.686]   - Field: 'label'
[17:28:17.686]   - Field: 'local'
[17:28:17.686]   - Field: 'owner'
[17:28:17.686]   - Field: 'envir'
[17:28:17.687]   - Field: 'packages'
[17:28:17.687]   - Field: 'gc'
[17:28:17.687]   - Field: 'conditions'
[17:28:17.687]   - Field: 'expr'
[17:28:17.687]   - Field: 'uuid'
[17:28:17.687]   - Field: 'seed'
[17:28:17.688]   - Field: 'version'
[17:28:17.688]   - Field: 'result'
[17:28:17.688]   - Field: 'asynchronous'
[17:28:17.688]   - Field: 'calls'
[17:28:17.688]   - Field: 'globals'
[17:28:17.689]   - Field: 'stdout'
[17:28:17.689]   - Field: 'earlySignal'
[17:28:17.689]   - Field: 'lazy'
[17:28:17.689]   - Field: 'state'
[17:28:17.689] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.689] - Launch lazy future ...
[17:28:17.690] Packages needed by the future expression (n = 0): <none>
[17:28:17.690] Packages needed by future strategies (n = 0): <none>
[17:28:17.690] {
[17:28:17.690]     {
[17:28:17.690]         {
[17:28:17.690]             ...future.startTime <- base::Sys.time()
[17:28:17.690]             {
[17:28:17.690]                 {
[17:28:17.690]                   {
[17:28:17.690]                     base::local({
[17:28:17.690]                       has_future <- base::requireNamespace("future", 
[17:28:17.690]                         quietly = TRUE)
[17:28:17.690]                       if (has_future) {
[17:28:17.690]                         ns <- base::getNamespace("future")
[17:28:17.690]                         version <- ns[[".package"]][["version"]]
[17:28:17.690]                         if (is.null(version)) 
[17:28:17.690]                           version <- utils::packageVersion("future")
[17:28:17.690]                       }
[17:28:17.690]                       else {
[17:28:17.690]                         version <- NULL
[17:28:17.690]                       }
[17:28:17.690]                       if (!has_future || version < "1.8.0") {
[17:28:17.690]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.690]                           "", base::R.version$version.string), 
[17:28:17.690]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.690]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.690]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.690]                             "release", "version")], collapse = " "), 
[17:28:17.690]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.690]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.690]                           info)
[17:28:17.690]                         info <- base::paste(info, collapse = "; ")
[17:28:17.690]                         if (!has_future) {
[17:28:17.690]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.690]                             info)
[17:28:17.690]                         }
[17:28:17.690]                         else {
[17:28:17.690]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.690]                             info, version)
[17:28:17.690]                         }
[17:28:17.690]                         base::stop(msg)
[17:28:17.690]                       }
[17:28:17.690]                     })
[17:28:17.690]                   }
[17:28:17.690]                   ...future.strategy.old <- future::plan("list")
[17:28:17.690]                   options(future.plan = NULL)
[17:28:17.690]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.690]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.690]                 }
[17:28:17.690]                 ...future.workdir <- getwd()
[17:28:17.690]             }
[17:28:17.690]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.690]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.690]         }
[17:28:17.690]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.690]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.690]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.690]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.690]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.690]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.690]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.690]             base::names(...future.oldOptions))
[17:28:17.690]     }
[17:28:17.690]     if (FALSE) {
[17:28:17.690]     }
[17:28:17.690]     else {
[17:28:17.690]         if (TRUE) {
[17:28:17.690]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.690]                 open = "w")
[17:28:17.690]         }
[17:28:17.690]         else {
[17:28:17.690]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.690]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.690]         }
[17:28:17.690]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.690]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.690]             base::sink(type = "output", split = FALSE)
[17:28:17.690]             base::close(...future.stdout)
[17:28:17.690]         }, add = TRUE)
[17:28:17.690]     }
[17:28:17.690]     ...future.frame <- base::sys.nframe()
[17:28:17.690]     ...future.conditions <- base::list()
[17:28:17.690]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.690]     if (FALSE) {
[17:28:17.690]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.690]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.690]     }
[17:28:17.690]     ...future.result <- base::tryCatch({
[17:28:17.690]         base::withCallingHandlers({
[17:28:17.690]             ...future.value <- base::withVisible(base::local({
[17:28:17.690]                 sample(x, size = 1L)
[17:28:17.690]             }))
[17:28:17.690]             future::FutureResult(value = ...future.value$value, 
[17:28:17.690]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.690]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.690]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.690]                     ...future.globalenv.names))
[17:28:17.690]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.690]         }, condition = base::local({
[17:28:17.690]             c <- base::c
[17:28:17.690]             inherits <- base::inherits
[17:28:17.690]             invokeRestart <- base::invokeRestart
[17:28:17.690]             length <- base::length
[17:28:17.690]             list <- base::list
[17:28:17.690]             seq.int <- base::seq.int
[17:28:17.690]             signalCondition <- base::signalCondition
[17:28:17.690]             sys.calls <- base::sys.calls
[17:28:17.690]             `[[` <- base::`[[`
[17:28:17.690]             `+` <- base::`+`
[17:28:17.690]             `<<-` <- base::`<<-`
[17:28:17.690]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.690]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.690]                   3L)]
[17:28:17.690]             }
[17:28:17.690]             function(cond) {
[17:28:17.690]                 is_error <- inherits(cond, "error")
[17:28:17.690]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.690]                   NULL)
[17:28:17.690]                 if (is_error) {
[17:28:17.690]                   sessionInformation <- function() {
[17:28:17.690]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.690]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.690]                       search = base::search(), system = base::Sys.info())
[17:28:17.690]                   }
[17:28:17.690]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.690]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.690]                     cond$call), session = sessionInformation(), 
[17:28:17.690]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.690]                   signalCondition(cond)
[17:28:17.690]                 }
[17:28:17.690]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.690]                 "immediateCondition"))) {
[17:28:17.690]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.690]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.690]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.690]                   if (TRUE && !signal) {
[17:28:17.690]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.690]                     {
[17:28:17.690]                       inherits <- base::inherits
[17:28:17.690]                       invokeRestart <- base::invokeRestart
[17:28:17.690]                       is.null <- base::is.null
[17:28:17.690]                       muffled <- FALSE
[17:28:17.690]                       if (inherits(cond, "message")) {
[17:28:17.690]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.690]                         if (muffled) 
[17:28:17.690]                           invokeRestart("muffleMessage")
[17:28:17.690]                       }
[17:28:17.690]                       else if (inherits(cond, "warning")) {
[17:28:17.690]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.690]                         if (muffled) 
[17:28:17.690]                           invokeRestart("muffleWarning")
[17:28:17.690]                       }
[17:28:17.690]                       else if (inherits(cond, "condition")) {
[17:28:17.690]                         if (!is.null(pattern)) {
[17:28:17.690]                           computeRestarts <- base::computeRestarts
[17:28:17.690]                           grepl <- base::grepl
[17:28:17.690]                           restarts <- computeRestarts(cond)
[17:28:17.690]                           for (restart in restarts) {
[17:28:17.690]                             name <- restart$name
[17:28:17.690]                             if (is.null(name)) 
[17:28:17.690]                               next
[17:28:17.690]                             if (!grepl(pattern, name)) 
[17:28:17.690]                               next
[17:28:17.690]                             invokeRestart(restart)
[17:28:17.690]                             muffled <- TRUE
[17:28:17.690]                             break
[17:28:17.690]                           }
[17:28:17.690]                         }
[17:28:17.690]                       }
[17:28:17.690]                       invisible(muffled)
[17:28:17.690]                     }
[17:28:17.690]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.690]                   }
[17:28:17.690]                 }
[17:28:17.690]                 else {
[17:28:17.690]                   if (TRUE) {
[17:28:17.690]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.690]                     {
[17:28:17.690]                       inherits <- base::inherits
[17:28:17.690]                       invokeRestart <- base::invokeRestart
[17:28:17.690]                       is.null <- base::is.null
[17:28:17.690]                       muffled <- FALSE
[17:28:17.690]                       if (inherits(cond, "message")) {
[17:28:17.690]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.690]                         if (muffled) 
[17:28:17.690]                           invokeRestart("muffleMessage")
[17:28:17.690]                       }
[17:28:17.690]                       else if (inherits(cond, "warning")) {
[17:28:17.690]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.690]                         if (muffled) 
[17:28:17.690]                           invokeRestart("muffleWarning")
[17:28:17.690]                       }
[17:28:17.690]                       else if (inherits(cond, "condition")) {
[17:28:17.690]                         if (!is.null(pattern)) {
[17:28:17.690]                           computeRestarts <- base::computeRestarts
[17:28:17.690]                           grepl <- base::grepl
[17:28:17.690]                           restarts <- computeRestarts(cond)
[17:28:17.690]                           for (restart in restarts) {
[17:28:17.690]                             name <- restart$name
[17:28:17.690]                             if (is.null(name)) 
[17:28:17.690]                               next
[17:28:17.690]                             if (!grepl(pattern, name)) 
[17:28:17.690]                               next
[17:28:17.690]                             invokeRestart(restart)
[17:28:17.690]                             muffled <- TRUE
[17:28:17.690]                             break
[17:28:17.690]                           }
[17:28:17.690]                         }
[17:28:17.690]                       }
[17:28:17.690]                       invisible(muffled)
[17:28:17.690]                     }
[17:28:17.690]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.690]                   }
[17:28:17.690]                 }
[17:28:17.690]             }
[17:28:17.690]         }))
[17:28:17.690]     }, error = function(ex) {
[17:28:17.690]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.690]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.690]                 ...future.rng), started = ...future.startTime, 
[17:28:17.690]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.690]             version = "1.8"), class = "FutureResult")
[17:28:17.690]     }, finally = {
[17:28:17.690]         if (!identical(...future.workdir, getwd())) 
[17:28:17.690]             setwd(...future.workdir)
[17:28:17.690]         {
[17:28:17.690]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.690]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.690]             }
[17:28:17.690]             base::options(...future.oldOptions)
[17:28:17.690]             if (.Platform$OS.type == "windows") {
[17:28:17.690]                 old_names <- names(...future.oldEnvVars)
[17:28:17.690]                 envs <- base::Sys.getenv()
[17:28:17.690]                 names <- names(envs)
[17:28:17.690]                 common <- intersect(names, old_names)
[17:28:17.690]                 added <- setdiff(names, old_names)
[17:28:17.690]                 removed <- setdiff(old_names, names)
[17:28:17.690]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.690]                   envs[common]]
[17:28:17.690]                 NAMES <- toupper(changed)
[17:28:17.690]                 args <- list()
[17:28:17.690]                 for (kk in seq_along(NAMES)) {
[17:28:17.690]                   name <- changed[[kk]]
[17:28:17.690]                   NAME <- NAMES[[kk]]
[17:28:17.690]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.690]                     next
[17:28:17.690]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.690]                 }
[17:28:17.690]                 NAMES <- toupper(added)
[17:28:17.690]                 for (kk in seq_along(NAMES)) {
[17:28:17.690]                   name <- added[[kk]]
[17:28:17.690]                   NAME <- NAMES[[kk]]
[17:28:17.690]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.690]                     next
[17:28:17.690]                   args[[name]] <- ""
[17:28:17.690]                 }
[17:28:17.690]                 NAMES <- toupper(removed)
[17:28:17.690]                 for (kk in seq_along(NAMES)) {
[17:28:17.690]                   name <- removed[[kk]]
[17:28:17.690]                   NAME <- NAMES[[kk]]
[17:28:17.690]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.690]                     next
[17:28:17.690]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.690]                 }
[17:28:17.690]                 if (length(args) > 0) 
[17:28:17.690]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.690]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.690]             }
[17:28:17.690]             else {
[17:28:17.690]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.690]             }
[17:28:17.690]             {
[17:28:17.690]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.690]                   0L) {
[17:28:17.690]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.690]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.690]                   base::options(opts)
[17:28:17.690]                 }
[17:28:17.690]                 {
[17:28:17.690]                   {
[17:28:17.690]                     base::assign(".Random.seed", c(10407L, -844755408L, 
[17:28:17.690]                     25280462L, 1658044765L, 1407237460L, 2042259082L, 
[17:28:17.690]                     1623183973L), envir = base::globalenv(), 
[17:28:17.690]                       inherits = FALSE)
[17:28:17.690]                     NULL
[17:28:17.690]                   }
[17:28:17.690]                   options(future.plan = NULL)
[17:28:17.690]                   if (is.na(NA_character_)) 
[17:28:17.690]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.690]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.690]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.690]                     .init = FALSE)
[17:28:17.690]                 }
[17:28:17.690]             }
[17:28:17.690]         }
[17:28:17.690]     })
[17:28:17.690]     if (TRUE) {
[17:28:17.690]         base::sink(type = "output", split = FALSE)
[17:28:17.690]         if (TRUE) {
[17:28:17.690]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.690]         }
[17:28:17.690]         else {
[17:28:17.690]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.690]         }
[17:28:17.690]         base::close(...future.stdout)
[17:28:17.690]         ...future.stdout <- NULL
[17:28:17.690]     }
[17:28:17.690]     ...future.result$conditions <- ...future.conditions
[17:28:17.690]     ...future.result$finished <- base::Sys.time()
[17:28:17.690]     ...future.result
[17:28:17.690] }
[17:28:17.694] assign_globals() ...
[17:28:17.694] List of 1
[17:28:17.694]  $ x: int [1:4] 0 1 2 3
[17:28:17.694]  - attr(*, "where")=List of 1
[17:28:17.694]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.694]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.694]  - attr(*, "resolved")= logi FALSE
[17:28:17.694]  - attr(*, "total_size")= num 64
[17:28:17.694]  - attr(*, "already-done")= logi TRUE
[17:28:17.697] - copied 'x' to environment
[17:28:17.697] assign_globals() ... done
[17:28:17.698] plan(): Setting new future strategy stack:
[17:28:17.698] List of future strategies:
[17:28:17.698] 1. sequential:
[17:28:17.698]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.698]    - tweaked: FALSE
[17:28:17.698]    - call: NULL
[17:28:17.698] plan(): nbrOfWorkers() = 1
[17:28:17.700] plan(): Setting new future strategy stack:
[17:28:17.700] List of future strategies:
[17:28:17.700] 1. sequential:
[17:28:17.700]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.700]    - tweaked: FALSE
[17:28:17.700]    - call: plan(strategy)
[17:28:17.700] plan(): nbrOfWorkers() = 1
[17:28:17.701] SequentialFuture started (and completed)
[17:28:17.701] - Launch lazy future ... done
[17:28:17.701] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-459284'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x0000026673a91d80
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.702] getGlobalsAndPackages() ...
[17:28:17.702] Searching for globals...
[17:28:17.703] - globals found: [3] '{', 'sample', 'x'
[17:28:17.703] Searching for globals ... DONE
[17:28:17.704] Resolving globals: FALSE
[17:28:17.705] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.705] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.706] - globals: [1] 'x'
[17:28:17.706] 
[17:28:17.706] getGlobalsAndPackages() ... DONE
[17:28:17.706] run() for 'Future' ...
[17:28:17.706] - state: 'created'
[17:28:17.707] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.707] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.707] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.707]   - Field: 'label'
[17:28:17.708]   - Field: 'local'
[17:28:17.708]   - Field: 'owner'
[17:28:17.708]   - Field: 'envir'
[17:28:17.708]   - Field: 'packages'
[17:28:17.708]   - Field: 'gc'
[17:28:17.708]   - Field: 'conditions'
[17:28:17.709]   - Field: 'expr'
[17:28:17.709]   - Field: 'uuid'
[17:28:17.709]   - Field: 'seed'
[17:28:17.709]   - Field: 'version'
[17:28:17.709]   - Field: 'result'
[17:28:17.709]   - Field: 'asynchronous'
[17:28:17.710]   - Field: 'calls'
[17:28:17.710]   - Field: 'globals'
[17:28:17.710]   - Field: 'stdout'
[17:28:17.710]   - Field: 'earlySignal'
[17:28:17.710]   - Field: 'lazy'
[17:28:17.711]   - Field: 'state'
[17:28:17.711] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.711] - Launch lazy future ...
[17:28:17.711] Packages needed by the future expression (n = 0): <none>
[17:28:17.711] Packages needed by future strategies (n = 0): <none>
[17:28:17.712] {
[17:28:17.712]     {
[17:28:17.712]         {
[17:28:17.712]             ...future.startTime <- base::Sys.time()
[17:28:17.712]             {
[17:28:17.712]                 {
[17:28:17.712]                   {
[17:28:17.712]                     base::local({
[17:28:17.712]                       has_future <- base::requireNamespace("future", 
[17:28:17.712]                         quietly = TRUE)
[17:28:17.712]                       if (has_future) {
[17:28:17.712]                         ns <- base::getNamespace("future")
[17:28:17.712]                         version <- ns[[".package"]][["version"]]
[17:28:17.712]                         if (is.null(version)) 
[17:28:17.712]                           version <- utils::packageVersion("future")
[17:28:17.712]                       }
[17:28:17.712]                       else {
[17:28:17.712]                         version <- NULL
[17:28:17.712]                       }
[17:28:17.712]                       if (!has_future || version < "1.8.0") {
[17:28:17.712]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.712]                           "", base::R.version$version.string), 
[17:28:17.712]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.712]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.712]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.712]                             "release", "version")], collapse = " "), 
[17:28:17.712]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.712]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.712]                           info)
[17:28:17.712]                         info <- base::paste(info, collapse = "; ")
[17:28:17.712]                         if (!has_future) {
[17:28:17.712]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.712]                             info)
[17:28:17.712]                         }
[17:28:17.712]                         else {
[17:28:17.712]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.712]                             info, version)
[17:28:17.712]                         }
[17:28:17.712]                         base::stop(msg)
[17:28:17.712]                       }
[17:28:17.712]                     })
[17:28:17.712]                   }
[17:28:17.712]                   ...future.strategy.old <- future::plan("list")
[17:28:17.712]                   options(future.plan = NULL)
[17:28:17.712]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.712]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.712]                 }
[17:28:17.712]                 ...future.workdir <- getwd()
[17:28:17.712]             }
[17:28:17.712]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.712]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.712]         }
[17:28:17.712]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.712]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.712]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.712]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.712]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.712]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.712]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.712]             base::names(...future.oldOptions))
[17:28:17.712]     }
[17:28:17.712]     if (FALSE) {
[17:28:17.712]     }
[17:28:17.712]     else {
[17:28:17.712]         if (TRUE) {
[17:28:17.712]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.712]                 open = "w")
[17:28:17.712]         }
[17:28:17.712]         else {
[17:28:17.712]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.712]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.712]         }
[17:28:17.712]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.712]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.712]             base::sink(type = "output", split = FALSE)
[17:28:17.712]             base::close(...future.stdout)
[17:28:17.712]         }, add = TRUE)
[17:28:17.712]     }
[17:28:17.712]     ...future.frame <- base::sys.nframe()
[17:28:17.712]     ...future.conditions <- base::list()
[17:28:17.712]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.712]     if (FALSE) {
[17:28:17.712]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.712]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.712]     }
[17:28:17.712]     ...future.result <- base::tryCatch({
[17:28:17.712]         base::withCallingHandlers({
[17:28:17.712]             ...future.value <- base::withVisible(base::local({
[17:28:17.712]                 sample(x, size = 1L)
[17:28:17.712]             }))
[17:28:17.712]             future::FutureResult(value = ...future.value$value, 
[17:28:17.712]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.712]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.712]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.712]                     ...future.globalenv.names))
[17:28:17.712]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.712]         }, condition = base::local({
[17:28:17.712]             c <- base::c
[17:28:17.712]             inherits <- base::inherits
[17:28:17.712]             invokeRestart <- base::invokeRestart
[17:28:17.712]             length <- base::length
[17:28:17.712]             list <- base::list
[17:28:17.712]             seq.int <- base::seq.int
[17:28:17.712]             signalCondition <- base::signalCondition
[17:28:17.712]             sys.calls <- base::sys.calls
[17:28:17.712]             `[[` <- base::`[[`
[17:28:17.712]             `+` <- base::`+`
[17:28:17.712]             `<<-` <- base::`<<-`
[17:28:17.712]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.712]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.712]                   3L)]
[17:28:17.712]             }
[17:28:17.712]             function(cond) {
[17:28:17.712]                 is_error <- inherits(cond, "error")
[17:28:17.712]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.712]                   NULL)
[17:28:17.712]                 if (is_error) {
[17:28:17.712]                   sessionInformation <- function() {
[17:28:17.712]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.712]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.712]                       search = base::search(), system = base::Sys.info())
[17:28:17.712]                   }
[17:28:17.712]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.712]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.712]                     cond$call), session = sessionInformation(), 
[17:28:17.712]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.712]                   signalCondition(cond)
[17:28:17.712]                 }
[17:28:17.712]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.712]                 "immediateCondition"))) {
[17:28:17.712]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.712]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.712]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.712]                   if (TRUE && !signal) {
[17:28:17.712]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.712]                     {
[17:28:17.712]                       inherits <- base::inherits
[17:28:17.712]                       invokeRestart <- base::invokeRestart
[17:28:17.712]                       is.null <- base::is.null
[17:28:17.712]                       muffled <- FALSE
[17:28:17.712]                       if (inherits(cond, "message")) {
[17:28:17.712]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.712]                         if (muffled) 
[17:28:17.712]                           invokeRestart("muffleMessage")
[17:28:17.712]                       }
[17:28:17.712]                       else if (inherits(cond, "warning")) {
[17:28:17.712]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.712]                         if (muffled) 
[17:28:17.712]                           invokeRestart("muffleWarning")
[17:28:17.712]                       }
[17:28:17.712]                       else if (inherits(cond, "condition")) {
[17:28:17.712]                         if (!is.null(pattern)) {
[17:28:17.712]                           computeRestarts <- base::computeRestarts
[17:28:17.712]                           grepl <- base::grepl
[17:28:17.712]                           restarts <- computeRestarts(cond)
[17:28:17.712]                           for (restart in restarts) {
[17:28:17.712]                             name <- restart$name
[17:28:17.712]                             if (is.null(name)) 
[17:28:17.712]                               next
[17:28:17.712]                             if (!grepl(pattern, name)) 
[17:28:17.712]                               next
[17:28:17.712]                             invokeRestart(restart)
[17:28:17.712]                             muffled <- TRUE
[17:28:17.712]                             break
[17:28:17.712]                           }
[17:28:17.712]                         }
[17:28:17.712]                       }
[17:28:17.712]                       invisible(muffled)
[17:28:17.712]                     }
[17:28:17.712]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.712]                   }
[17:28:17.712]                 }
[17:28:17.712]                 else {
[17:28:17.712]                   if (TRUE) {
[17:28:17.712]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.712]                     {
[17:28:17.712]                       inherits <- base::inherits
[17:28:17.712]                       invokeRestart <- base::invokeRestart
[17:28:17.712]                       is.null <- base::is.null
[17:28:17.712]                       muffled <- FALSE
[17:28:17.712]                       if (inherits(cond, "message")) {
[17:28:17.712]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.712]                         if (muffled) 
[17:28:17.712]                           invokeRestart("muffleMessage")
[17:28:17.712]                       }
[17:28:17.712]                       else if (inherits(cond, "warning")) {
[17:28:17.712]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.712]                         if (muffled) 
[17:28:17.712]                           invokeRestart("muffleWarning")
[17:28:17.712]                       }
[17:28:17.712]                       else if (inherits(cond, "condition")) {
[17:28:17.712]                         if (!is.null(pattern)) {
[17:28:17.712]                           computeRestarts <- base::computeRestarts
[17:28:17.712]                           grepl <- base::grepl
[17:28:17.712]                           restarts <- computeRestarts(cond)
[17:28:17.712]                           for (restart in restarts) {
[17:28:17.712]                             name <- restart$name
[17:28:17.712]                             if (is.null(name)) 
[17:28:17.712]                               next
[17:28:17.712]                             if (!grepl(pattern, name)) 
[17:28:17.712]                               next
[17:28:17.712]                             invokeRestart(restart)
[17:28:17.712]                             muffled <- TRUE
[17:28:17.712]                             break
[17:28:17.712]                           }
[17:28:17.712]                         }
[17:28:17.712]                       }
[17:28:17.712]                       invisible(muffled)
[17:28:17.712]                     }
[17:28:17.712]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.712]                   }
[17:28:17.712]                 }
[17:28:17.712]             }
[17:28:17.712]         }))
[17:28:17.712]     }, error = function(ex) {
[17:28:17.712]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.712]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.712]                 ...future.rng), started = ...future.startTime, 
[17:28:17.712]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.712]             version = "1.8"), class = "FutureResult")
[17:28:17.712]     }, finally = {
[17:28:17.712]         if (!identical(...future.workdir, getwd())) 
[17:28:17.712]             setwd(...future.workdir)
[17:28:17.712]         {
[17:28:17.712]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.712]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.712]             }
[17:28:17.712]             base::options(...future.oldOptions)
[17:28:17.712]             if (.Platform$OS.type == "windows") {
[17:28:17.712]                 old_names <- names(...future.oldEnvVars)
[17:28:17.712]                 envs <- base::Sys.getenv()
[17:28:17.712]                 names <- names(envs)
[17:28:17.712]                 common <- intersect(names, old_names)
[17:28:17.712]                 added <- setdiff(names, old_names)
[17:28:17.712]                 removed <- setdiff(old_names, names)
[17:28:17.712]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.712]                   envs[common]]
[17:28:17.712]                 NAMES <- toupper(changed)
[17:28:17.712]                 args <- list()
[17:28:17.712]                 for (kk in seq_along(NAMES)) {
[17:28:17.712]                   name <- changed[[kk]]
[17:28:17.712]                   NAME <- NAMES[[kk]]
[17:28:17.712]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.712]                     next
[17:28:17.712]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.712]                 }
[17:28:17.712]                 NAMES <- toupper(added)
[17:28:17.712]                 for (kk in seq_along(NAMES)) {
[17:28:17.712]                   name <- added[[kk]]
[17:28:17.712]                   NAME <- NAMES[[kk]]
[17:28:17.712]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.712]                     next
[17:28:17.712]                   args[[name]] <- ""
[17:28:17.712]                 }
[17:28:17.712]                 NAMES <- toupper(removed)
[17:28:17.712]                 for (kk in seq_along(NAMES)) {
[17:28:17.712]                   name <- removed[[kk]]
[17:28:17.712]                   NAME <- NAMES[[kk]]
[17:28:17.712]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.712]                     next
[17:28:17.712]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.712]                 }
[17:28:17.712]                 if (length(args) > 0) 
[17:28:17.712]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.712]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.712]             }
[17:28:17.712]             else {
[17:28:17.712]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.712]             }
[17:28:17.712]             {
[17:28:17.712]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.712]                   0L) {
[17:28:17.712]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.712]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.712]                   base::options(opts)
[17:28:17.712]                 }
[17:28:17.712]                 {
[17:28:17.712]                   {
[17:28:17.712]                     base::assign(".Random.seed", c(10407L, 1658044765L, 
[17:28:17.712]                     -2036003017L, 624480187L, 1623183973L, -1176807178L, 
[17:28:17.712]                     -708227568L), envir = base::globalenv(), 
[17:28:17.712]                       inherits = FALSE)
[17:28:17.712]                     NULL
[17:28:17.712]                   }
[17:28:17.712]                   options(future.plan = NULL)
[17:28:17.712]                   if (is.na(NA_character_)) 
[17:28:17.712]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.712]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.712]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.712]                     .init = FALSE)
[17:28:17.712]                 }
[17:28:17.712]             }
[17:28:17.712]         }
[17:28:17.712]     })
[17:28:17.712]     if (TRUE) {
[17:28:17.712]         base::sink(type = "output", split = FALSE)
[17:28:17.712]         if (TRUE) {
[17:28:17.712]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.712]         }
[17:28:17.712]         else {
[17:28:17.712]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.712]         }
[17:28:17.712]         base::close(...future.stdout)
[17:28:17.712]         ...future.stdout <- NULL
[17:28:17.712]     }
[17:28:17.712]     ...future.result$conditions <- ...future.conditions
[17:28:17.712]     ...future.result$finished <- base::Sys.time()
[17:28:17.712]     ...future.result
[17:28:17.712] }
[17:28:17.715] assign_globals() ...
[17:28:17.716] List of 1
[17:28:17.716]  $ x: int [1:4] 0 1 2 3
[17:28:17.716]  - attr(*, "where")=List of 1
[17:28:17.716]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.716]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.716]  - attr(*, "resolved")= logi FALSE
[17:28:17.716]  - attr(*, "total_size")= num 64
[17:28:17.716]  - attr(*, "already-done")= logi TRUE
[17:28:17.718] - copied 'x' to environment
[17:28:17.719] assign_globals() ... done
[17:28:17.719] plan(): Setting new future strategy stack:
[17:28:17.719] List of future strategies:
[17:28:17.719] 1. sequential:
[17:28:17.719]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.719]    - tweaked: FALSE
[17:28:17.719]    - call: NULL
[17:28:17.720] plan(): nbrOfWorkers() = 1
[17:28:17.721] plan(): Setting new future strategy stack:
[17:28:17.721] List of future strategies:
[17:28:17.721] 1. sequential:
[17:28:17.721]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.721]    - tweaked: FALSE
[17:28:17.721]    - call: plan(strategy)
[17:28:17.722] plan(): nbrOfWorkers() = 1
[17:28:17.722] SequentialFuture started (and completed)
[17:28:17.722] - Launch lazy future ... done
[17:28:17.722] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-610160'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x0000026673a91d80
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.723] getGlobalsAndPackages() ...
[17:28:17.723] Searching for globals...
[17:28:17.725] - globals found: [3] '{', 'sample', 'x'
[17:28:17.725] Searching for globals ... DONE
[17:28:17.725] Resolving globals: FALSE
[17:28:17.725] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.726] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.726] - globals: [1] 'x'
[17:28:17.726] 
[17:28:17.726] getGlobalsAndPackages() ... DONE
[17:28:17.727] run() for 'Future' ...
[17:28:17.727] - state: 'created'
[17:28:17.727] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.727] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.728] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.728]   - Field: 'label'
[17:28:17.728]   - Field: 'local'
[17:28:17.728]   - Field: 'owner'
[17:28:17.728]   - Field: 'envir'
[17:28:17.728]   - Field: 'packages'
[17:28:17.729]   - Field: 'gc'
[17:28:17.729]   - Field: 'conditions'
[17:28:17.729]   - Field: 'expr'
[17:28:17.729]   - Field: 'uuid'
[17:28:17.729]   - Field: 'seed'
[17:28:17.730]   - Field: 'version'
[17:28:17.730]   - Field: 'result'
[17:28:17.730]   - Field: 'asynchronous'
[17:28:17.730]   - Field: 'calls'
[17:28:17.730]   - Field: 'globals'
[17:28:17.730]   - Field: 'stdout'
[17:28:17.731]   - Field: 'earlySignal'
[17:28:17.731]   - Field: 'lazy'
[17:28:17.731]   - Field: 'state'
[17:28:17.731] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.731] - Launch lazy future ...
[17:28:17.731] Packages needed by the future expression (n = 0): <none>
[17:28:17.732] Packages needed by future strategies (n = 0): <none>
[17:28:17.732] {
[17:28:17.732]     {
[17:28:17.732]         {
[17:28:17.732]             ...future.startTime <- base::Sys.time()
[17:28:17.732]             {
[17:28:17.732]                 {
[17:28:17.732]                   {
[17:28:17.732]                     base::local({
[17:28:17.732]                       has_future <- base::requireNamespace("future", 
[17:28:17.732]                         quietly = TRUE)
[17:28:17.732]                       if (has_future) {
[17:28:17.732]                         ns <- base::getNamespace("future")
[17:28:17.732]                         version <- ns[[".package"]][["version"]]
[17:28:17.732]                         if (is.null(version)) 
[17:28:17.732]                           version <- utils::packageVersion("future")
[17:28:17.732]                       }
[17:28:17.732]                       else {
[17:28:17.732]                         version <- NULL
[17:28:17.732]                       }
[17:28:17.732]                       if (!has_future || version < "1.8.0") {
[17:28:17.732]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.732]                           "", base::R.version$version.string), 
[17:28:17.732]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.732]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.732]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.732]                             "release", "version")], collapse = " "), 
[17:28:17.732]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.732]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.732]                           info)
[17:28:17.732]                         info <- base::paste(info, collapse = "; ")
[17:28:17.732]                         if (!has_future) {
[17:28:17.732]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.732]                             info)
[17:28:17.732]                         }
[17:28:17.732]                         else {
[17:28:17.732]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.732]                             info, version)
[17:28:17.732]                         }
[17:28:17.732]                         base::stop(msg)
[17:28:17.732]                       }
[17:28:17.732]                     })
[17:28:17.732]                   }
[17:28:17.732]                   ...future.strategy.old <- future::plan("list")
[17:28:17.732]                   options(future.plan = NULL)
[17:28:17.732]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.732]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.732]                 }
[17:28:17.732]                 ...future.workdir <- getwd()
[17:28:17.732]             }
[17:28:17.732]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.732]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.732]         }
[17:28:17.732]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.732]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.732]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.732]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.732]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.732]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.732]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.732]             base::names(...future.oldOptions))
[17:28:17.732]     }
[17:28:17.732]     if (FALSE) {
[17:28:17.732]     }
[17:28:17.732]     else {
[17:28:17.732]         if (TRUE) {
[17:28:17.732]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.732]                 open = "w")
[17:28:17.732]         }
[17:28:17.732]         else {
[17:28:17.732]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.732]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.732]         }
[17:28:17.732]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.732]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.732]             base::sink(type = "output", split = FALSE)
[17:28:17.732]             base::close(...future.stdout)
[17:28:17.732]         }, add = TRUE)
[17:28:17.732]     }
[17:28:17.732]     ...future.frame <- base::sys.nframe()
[17:28:17.732]     ...future.conditions <- base::list()
[17:28:17.732]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.732]     if (FALSE) {
[17:28:17.732]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.732]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.732]     }
[17:28:17.732]     ...future.result <- base::tryCatch({
[17:28:17.732]         base::withCallingHandlers({
[17:28:17.732]             ...future.value <- base::withVisible(base::local({
[17:28:17.732]                 sample(x, size = 1L)
[17:28:17.732]             }))
[17:28:17.732]             future::FutureResult(value = ...future.value$value, 
[17:28:17.732]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.732]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.732]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.732]                     ...future.globalenv.names))
[17:28:17.732]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.732]         }, condition = base::local({
[17:28:17.732]             c <- base::c
[17:28:17.732]             inherits <- base::inherits
[17:28:17.732]             invokeRestart <- base::invokeRestart
[17:28:17.732]             length <- base::length
[17:28:17.732]             list <- base::list
[17:28:17.732]             seq.int <- base::seq.int
[17:28:17.732]             signalCondition <- base::signalCondition
[17:28:17.732]             sys.calls <- base::sys.calls
[17:28:17.732]             `[[` <- base::`[[`
[17:28:17.732]             `+` <- base::`+`
[17:28:17.732]             `<<-` <- base::`<<-`
[17:28:17.732]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.732]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.732]                   3L)]
[17:28:17.732]             }
[17:28:17.732]             function(cond) {
[17:28:17.732]                 is_error <- inherits(cond, "error")
[17:28:17.732]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.732]                   NULL)
[17:28:17.732]                 if (is_error) {
[17:28:17.732]                   sessionInformation <- function() {
[17:28:17.732]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.732]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.732]                       search = base::search(), system = base::Sys.info())
[17:28:17.732]                   }
[17:28:17.732]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.732]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.732]                     cond$call), session = sessionInformation(), 
[17:28:17.732]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.732]                   signalCondition(cond)
[17:28:17.732]                 }
[17:28:17.732]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.732]                 "immediateCondition"))) {
[17:28:17.732]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.732]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.732]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.732]                   if (TRUE && !signal) {
[17:28:17.732]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.732]                     {
[17:28:17.732]                       inherits <- base::inherits
[17:28:17.732]                       invokeRestart <- base::invokeRestart
[17:28:17.732]                       is.null <- base::is.null
[17:28:17.732]                       muffled <- FALSE
[17:28:17.732]                       if (inherits(cond, "message")) {
[17:28:17.732]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.732]                         if (muffled) 
[17:28:17.732]                           invokeRestart("muffleMessage")
[17:28:17.732]                       }
[17:28:17.732]                       else if (inherits(cond, "warning")) {
[17:28:17.732]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.732]                         if (muffled) 
[17:28:17.732]                           invokeRestart("muffleWarning")
[17:28:17.732]                       }
[17:28:17.732]                       else if (inherits(cond, "condition")) {
[17:28:17.732]                         if (!is.null(pattern)) {
[17:28:17.732]                           computeRestarts <- base::computeRestarts
[17:28:17.732]                           grepl <- base::grepl
[17:28:17.732]                           restarts <- computeRestarts(cond)
[17:28:17.732]                           for (restart in restarts) {
[17:28:17.732]                             name <- restart$name
[17:28:17.732]                             if (is.null(name)) 
[17:28:17.732]                               next
[17:28:17.732]                             if (!grepl(pattern, name)) 
[17:28:17.732]                               next
[17:28:17.732]                             invokeRestart(restart)
[17:28:17.732]                             muffled <- TRUE
[17:28:17.732]                             break
[17:28:17.732]                           }
[17:28:17.732]                         }
[17:28:17.732]                       }
[17:28:17.732]                       invisible(muffled)
[17:28:17.732]                     }
[17:28:17.732]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.732]                   }
[17:28:17.732]                 }
[17:28:17.732]                 else {
[17:28:17.732]                   if (TRUE) {
[17:28:17.732]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.732]                     {
[17:28:17.732]                       inherits <- base::inherits
[17:28:17.732]                       invokeRestart <- base::invokeRestart
[17:28:17.732]                       is.null <- base::is.null
[17:28:17.732]                       muffled <- FALSE
[17:28:17.732]                       if (inherits(cond, "message")) {
[17:28:17.732]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.732]                         if (muffled) 
[17:28:17.732]                           invokeRestart("muffleMessage")
[17:28:17.732]                       }
[17:28:17.732]                       else if (inherits(cond, "warning")) {
[17:28:17.732]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.732]                         if (muffled) 
[17:28:17.732]                           invokeRestart("muffleWarning")
[17:28:17.732]                       }
[17:28:17.732]                       else if (inherits(cond, "condition")) {
[17:28:17.732]                         if (!is.null(pattern)) {
[17:28:17.732]                           computeRestarts <- base::computeRestarts
[17:28:17.732]                           grepl <- base::grepl
[17:28:17.732]                           restarts <- computeRestarts(cond)
[17:28:17.732]                           for (restart in restarts) {
[17:28:17.732]                             name <- restart$name
[17:28:17.732]                             if (is.null(name)) 
[17:28:17.732]                               next
[17:28:17.732]                             if (!grepl(pattern, name)) 
[17:28:17.732]                               next
[17:28:17.732]                             invokeRestart(restart)
[17:28:17.732]                             muffled <- TRUE
[17:28:17.732]                             break
[17:28:17.732]                           }
[17:28:17.732]                         }
[17:28:17.732]                       }
[17:28:17.732]                       invisible(muffled)
[17:28:17.732]                     }
[17:28:17.732]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.732]                   }
[17:28:17.732]                 }
[17:28:17.732]             }
[17:28:17.732]         }))
[17:28:17.732]     }, error = function(ex) {
[17:28:17.732]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.732]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.732]                 ...future.rng), started = ...future.startTime, 
[17:28:17.732]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.732]             version = "1.8"), class = "FutureResult")
[17:28:17.732]     }, finally = {
[17:28:17.732]         if (!identical(...future.workdir, getwd())) 
[17:28:17.732]             setwd(...future.workdir)
[17:28:17.732]         {
[17:28:17.732]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.732]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.732]             }
[17:28:17.732]             base::options(...future.oldOptions)
[17:28:17.732]             if (.Platform$OS.type == "windows") {
[17:28:17.732]                 old_names <- names(...future.oldEnvVars)
[17:28:17.732]                 envs <- base::Sys.getenv()
[17:28:17.732]                 names <- names(envs)
[17:28:17.732]                 common <- intersect(names, old_names)
[17:28:17.732]                 added <- setdiff(names, old_names)
[17:28:17.732]                 removed <- setdiff(old_names, names)
[17:28:17.732]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.732]                   envs[common]]
[17:28:17.732]                 NAMES <- toupper(changed)
[17:28:17.732]                 args <- list()
[17:28:17.732]                 for (kk in seq_along(NAMES)) {
[17:28:17.732]                   name <- changed[[kk]]
[17:28:17.732]                   NAME <- NAMES[[kk]]
[17:28:17.732]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.732]                     next
[17:28:17.732]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.732]                 }
[17:28:17.732]                 NAMES <- toupper(added)
[17:28:17.732]                 for (kk in seq_along(NAMES)) {
[17:28:17.732]                   name <- added[[kk]]
[17:28:17.732]                   NAME <- NAMES[[kk]]
[17:28:17.732]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.732]                     next
[17:28:17.732]                   args[[name]] <- ""
[17:28:17.732]                 }
[17:28:17.732]                 NAMES <- toupper(removed)
[17:28:17.732]                 for (kk in seq_along(NAMES)) {
[17:28:17.732]                   name <- removed[[kk]]
[17:28:17.732]                   NAME <- NAMES[[kk]]
[17:28:17.732]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.732]                     next
[17:28:17.732]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.732]                 }
[17:28:17.732]                 if (length(args) > 0) 
[17:28:17.732]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.732]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.732]             }
[17:28:17.732]             else {
[17:28:17.732]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.732]             }
[17:28:17.732]             {
[17:28:17.732]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.732]                   0L) {
[17:28:17.732]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.732]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.732]                   base::options(opts)
[17:28:17.732]                 }
[17:28:17.732]                 {
[17:28:17.732]                   {
[17:28:17.732]                     base::assign(".Random.seed", c(10407L, 624480187L, 
[17:28:17.732]                     487568585L, -1953630238L, -708227568L, 1559387678L, 
[17:28:17.732]                     2078823719L), envir = base::globalenv(), 
[17:28:17.732]                       inherits = FALSE)
[17:28:17.732]                     NULL
[17:28:17.732]                   }
[17:28:17.732]                   options(future.plan = NULL)
[17:28:17.732]                   if (is.na(NA_character_)) 
[17:28:17.732]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.732]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.732]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.732]                     .init = FALSE)
[17:28:17.732]                 }
[17:28:17.732]             }
[17:28:17.732]         }
[17:28:17.732]     })
[17:28:17.732]     if (TRUE) {
[17:28:17.732]         base::sink(type = "output", split = FALSE)
[17:28:17.732]         if (TRUE) {
[17:28:17.732]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.732]         }
[17:28:17.732]         else {
[17:28:17.732]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.732]         }
[17:28:17.732]         base::close(...future.stdout)
[17:28:17.732]         ...future.stdout <- NULL
[17:28:17.732]     }
[17:28:17.732]     ...future.result$conditions <- ...future.conditions
[17:28:17.732]     ...future.result$finished <- base::Sys.time()
[17:28:17.732]     ...future.result
[17:28:17.732] }
[17:28:17.736] assign_globals() ...
[17:28:17.736] List of 1
[17:28:17.736]  $ x: int [1:4] 0 1 2 3
[17:28:17.736]  - attr(*, "where")=List of 1
[17:28:17.736]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.736]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.736]  - attr(*, "resolved")= logi FALSE
[17:28:17.736]  - attr(*, "total_size")= num 64
[17:28:17.736]  - attr(*, "already-done")= logi TRUE
[17:28:17.739] - copied 'x' to environment
[17:28:17.739] assign_globals() ... done
[17:28:17.739] plan(): Setting new future strategy stack:
[17:28:17.740] List of future strategies:
[17:28:17.740] 1. sequential:
[17:28:17.740]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.740]    - tweaked: FALSE
[17:28:17.740]    - call: NULL
[17:28:17.741] plan(): nbrOfWorkers() = 1
[17:28:17.742] plan(): Setting new future strategy stack:
[17:28:17.742] List of future strategies:
[17:28:17.742] 1. sequential:
[17:28:17.742]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.742]    - tweaked: FALSE
[17:28:17.742]    - call: plan(strategy)
[17:28:17.743] plan(): nbrOfWorkers() = 1
[17:28:17.743] SequentialFuture started (and completed)
[17:28:17.743] - Launch lazy future ... done
[17:28:17.744] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-855974'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x0000026673a91d80
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.745] resolve() on list ...
[17:28:17.745]  recursive: 0
[17:28:17.745]  length: 4
[17:28:17.745] 
[17:28:17.745] resolved() for 'SequentialFuture' ...
[17:28:17.745] - state: 'finished'
[17:28:17.746] - run: TRUE
[17:28:17.746] - result: 'FutureResult'
[17:28:17.746] resolved() for 'SequentialFuture' ... done
[17:28:17.746] Future #1
[17:28:17.746] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:28:17.747] - nx: 4
[17:28:17.747] - relay: TRUE
[17:28:17.747] - stdout: TRUE
[17:28:17.747] - signal: TRUE
[17:28:17.747] - resignal: FALSE
[17:28:17.747] - force: TRUE
[17:28:17.747] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.748] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.748]  - until=1
[17:28:17.748]  - relaying element #1
[17:28:17.748] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.748] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.749] signalConditionsASAP(SequentialFuture, pos=1) ... done
[17:28:17.749]  length: 3 (resolved future 1)
[17:28:17.749] resolved() for 'SequentialFuture' ...
[17:28:17.749] - state: 'finished'
[17:28:17.749] - run: TRUE
[17:28:17.750] - result: 'FutureResult'
[17:28:17.750] resolved() for 'SequentialFuture' ... done
[17:28:17.750] Future #2
[17:28:17.750] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:28:17.750] - nx: 4
[17:28:17.750] - relay: TRUE
[17:28:17.751] - stdout: TRUE
[17:28:17.751] - signal: TRUE
[17:28:17.751] - resignal: FALSE
[17:28:17.751] - force: TRUE
[17:28:17.751] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.751] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.752]  - until=2
[17:28:17.752]  - relaying element #2
[17:28:17.752] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.752] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.752] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:28:17.752]  length: 2 (resolved future 2)
[17:28:17.753] resolved() for 'SequentialFuture' ...
[17:28:17.753] - state: 'finished'
[17:28:17.753] - run: TRUE
[17:28:17.753] - result: 'FutureResult'
[17:28:17.753] resolved() for 'SequentialFuture' ... done
[17:28:17.754] Future #3
[17:28:17.754] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:28:17.754] - nx: 4
[17:28:17.754] - relay: TRUE
[17:28:17.754] - stdout: TRUE
[17:28:17.754] - signal: TRUE
[17:28:17.754] - resignal: FALSE
[17:28:17.755] - force: TRUE
[17:28:17.755] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.755] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.755]  - until=3
[17:28:17.755]  - relaying element #3
[17:28:17.756] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.756] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.756] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:28:17.756]  length: 1 (resolved future 3)
[17:28:17.756] resolved() for 'SequentialFuture' ...
[17:28:17.756] - state: 'finished'
[17:28:17.757] - run: TRUE
[17:28:17.757] - result: 'FutureResult'
[17:28:17.757] resolved() for 'SequentialFuture' ... done
[17:28:17.757] Future #4
[17:28:17.757] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:28:17.757] - nx: 4
[17:28:17.758] - relay: TRUE
[17:28:17.758] - stdout: TRUE
[17:28:17.758] - signal: TRUE
[17:28:17.758] - resignal: FALSE
[17:28:17.758] - force: TRUE
[17:28:17.758] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.758] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.759]  - until=4
[17:28:17.759]  - relaying element #4
[17:28:17.759] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.759] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.759] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:28:17.760]  length: 0 (resolved future 4)
[17:28:17.760] Relaying remaining futures
[17:28:17.760] signalConditionsASAP(NULL, pos=0) ...
[17:28:17.760] - nx: 4
[17:28:17.760] - relay: TRUE
[17:28:17.760] - stdout: TRUE
[17:28:17.760] - signal: TRUE
[17:28:17.761] - resignal: FALSE
[17:28:17.761] - force: TRUE
[17:28:17.761] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.761] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:28:17.761] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.761] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.762] signalConditionsASAP(NULL, pos=0) ... done
[17:28:17.762] resolve() on list ... DONE
[[1]]
[1] 3

[[2]]
[1] 1

[[3]]
[1] 1

[[4]]
[1] 3

[17:28:17.762] getGlobalsAndPackages() ...
[17:28:17.763] Searching for globals...
[17:28:17.764] - globals found: [3] '{', 'sample', 'x'
[17:28:17.764] Searching for globals ... DONE
[17:28:17.764] Resolving globals: FALSE
[17:28:17.764] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.765] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.765] - globals: [1] 'x'
[17:28:17.765] 
[17:28:17.765] getGlobalsAndPackages() ... DONE
[17:28:17.766] run() for 'Future' ...
[17:28:17.766] - state: 'created'
[17:28:17.766] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.767] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.767] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.767]   - Field: 'label'
[17:28:17.767]   - Field: 'local'
[17:28:17.767]   - Field: 'owner'
[17:28:17.767]   - Field: 'envir'
[17:28:17.768]   - Field: 'packages'
[17:28:17.768]   - Field: 'gc'
[17:28:17.768]   - Field: 'conditions'
[17:28:17.768]   - Field: 'expr'
[17:28:17.768]   - Field: 'uuid'
[17:28:17.768]   - Field: 'seed'
[17:28:17.769]   - Field: 'version'
[17:28:17.769]   - Field: 'result'
[17:28:17.769]   - Field: 'asynchronous'
[17:28:17.769]   - Field: 'calls'
[17:28:17.769]   - Field: 'globals'
[17:28:17.769]   - Field: 'stdout'
[17:28:17.770]   - Field: 'earlySignal'
[17:28:17.770]   - Field: 'lazy'
[17:28:17.770]   - Field: 'state'
[17:28:17.770] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.770] - Launch lazy future ...
[17:28:17.771] Packages needed by the future expression (n = 0): <none>
[17:28:17.771] Packages needed by future strategies (n = 0): <none>
[17:28:17.771] {
[17:28:17.771]     {
[17:28:17.771]         {
[17:28:17.771]             ...future.startTime <- base::Sys.time()
[17:28:17.771]             {
[17:28:17.771]                 {
[17:28:17.771]                   {
[17:28:17.771]                     base::local({
[17:28:17.771]                       has_future <- base::requireNamespace("future", 
[17:28:17.771]                         quietly = TRUE)
[17:28:17.771]                       if (has_future) {
[17:28:17.771]                         ns <- base::getNamespace("future")
[17:28:17.771]                         version <- ns[[".package"]][["version"]]
[17:28:17.771]                         if (is.null(version)) 
[17:28:17.771]                           version <- utils::packageVersion("future")
[17:28:17.771]                       }
[17:28:17.771]                       else {
[17:28:17.771]                         version <- NULL
[17:28:17.771]                       }
[17:28:17.771]                       if (!has_future || version < "1.8.0") {
[17:28:17.771]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.771]                           "", base::R.version$version.string), 
[17:28:17.771]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.771]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.771]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.771]                             "release", "version")], collapse = " "), 
[17:28:17.771]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.771]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.771]                           info)
[17:28:17.771]                         info <- base::paste(info, collapse = "; ")
[17:28:17.771]                         if (!has_future) {
[17:28:17.771]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.771]                             info)
[17:28:17.771]                         }
[17:28:17.771]                         else {
[17:28:17.771]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.771]                             info, version)
[17:28:17.771]                         }
[17:28:17.771]                         base::stop(msg)
[17:28:17.771]                       }
[17:28:17.771]                     })
[17:28:17.771]                   }
[17:28:17.771]                   ...future.strategy.old <- future::plan("list")
[17:28:17.771]                   options(future.plan = NULL)
[17:28:17.771]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.771]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.771]                 }
[17:28:17.771]                 ...future.workdir <- getwd()
[17:28:17.771]             }
[17:28:17.771]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.771]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.771]         }
[17:28:17.771]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.771]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.771]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.771]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.771]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.771]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.771]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.771]             base::names(...future.oldOptions))
[17:28:17.771]     }
[17:28:17.771]     if (FALSE) {
[17:28:17.771]     }
[17:28:17.771]     else {
[17:28:17.771]         if (TRUE) {
[17:28:17.771]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.771]                 open = "w")
[17:28:17.771]         }
[17:28:17.771]         else {
[17:28:17.771]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.771]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.771]         }
[17:28:17.771]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.771]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.771]             base::sink(type = "output", split = FALSE)
[17:28:17.771]             base::close(...future.stdout)
[17:28:17.771]         }, add = TRUE)
[17:28:17.771]     }
[17:28:17.771]     ...future.frame <- base::sys.nframe()
[17:28:17.771]     ...future.conditions <- base::list()
[17:28:17.771]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.771]     if (FALSE) {
[17:28:17.771]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.771]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.771]     }
[17:28:17.771]     ...future.result <- base::tryCatch({
[17:28:17.771]         base::withCallingHandlers({
[17:28:17.771]             ...future.value <- base::withVisible(base::local({
[17:28:17.771]                 sample(x, size = 1L)
[17:28:17.771]             }))
[17:28:17.771]             future::FutureResult(value = ...future.value$value, 
[17:28:17.771]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.771]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.771]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.771]                     ...future.globalenv.names))
[17:28:17.771]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.771]         }, condition = base::local({
[17:28:17.771]             c <- base::c
[17:28:17.771]             inherits <- base::inherits
[17:28:17.771]             invokeRestart <- base::invokeRestart
[17:28:17.771]             length <- base::length
[17:28:17.771]             list <- base::list
[17:28:17.771]             seq.int <- base::seq.int
[17:28:17.771]             signalCondition <- base::signalCondition
[17:28:17.771]             sys.calls <- base::sys.calls
[17:28:17.771]             `[[` <- base::`[[`
[17:28:17.771]             `+` <- base::`+`
[17:28:17.771]             `<<-` <- base::`<<-`
[17:28:17.771]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.771]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.771]                   3L)]
[17:28:17.771]             }
[17:28:17.771]             function(cond) {
[17:28:17.771]                 is_error <- inherits(cond, "error")
[17:28:17.771]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.771]                   NULL)
[17:28:17.771]                 if (is_error) {
[17:28:17.771]                   sessionInformation <- function() {
[17:28:17.771]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.771]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.771]                       search = base::search(), system = base::Sys.info())
[17:28:17.771]                   }
[17:28:17.771]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.771]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.771]                     cond$call), session = sessionInformation(), 
[17:28:17.771]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.771]                   signalCondition(cond)
[17:28:17.771]                 }
[17:28:17.771]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.771]                 "immediateCondition"))) {
[17:28:17.771]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.771]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.771]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.771]                   if (TRUE && !signal) {
[17:28:17.771]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.771]                     {
[17:28:17.771]                       inherits <- base::inherits
[17:28:17.771]                       invokeRestart <- base::invokeRestart
[17:28:17.771]                       is.null <- base::is.null
[17:28:17.771]                       muffled <- FALSE
[17:28:17.771]                       if (inherits(cond, "message")) {
[17:28:17.771]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.771]                         if (muffled) 
[17:28:17.771]                           invokeRestart("muffleMessage")
[17:28:17.771]                       }
[17:28:17.771]                       else if (inherits(cond, "warning")) {
[17:28:17.771]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.771]                         if (muffled) 
[17:28:17.771]                           invokeRestart("muffleWarning")
[17:28:17.771]                       }
[17:28:17.771]                       else if (inherits(cond, "condition")) {
[17:28:17.771]                         if (!is.null(pattern)) {
[17:28:17.771]                           computeRestarts <- base::computeRestarts
[17:28:17.771]                           grepl <- base::grepl
[17:28:17.771]                           restarts <- computeRestarts(cond)
[17:28:17.771]                           for (restart in restarts) {
[17:28:17.771]                             name <- restart$name
[17:28:17.771]                             if (is.null(name)) 
[17:28:17.771]                               next
[17:28:17.771]                             if (!grepl(pattern, name)) 
[17:28:17.771]                               next
[17:28:17.771]                             invokeRestart(restart)
[17:28:17.771]                             muffled <- TRUE
[17:28:17.771]                             break
[17:28:17.771]                           }
[17:28:17.771]                         }
[17:28:17.771]                       }
[17:28:17.771]                       invisible(muffled)
[17:28:17.771]                     }
[17:28:17.771]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.771]                   }
[17:28:17.771]                 }
[17:28:17.771]                 else {
[17:28:17.771]                   if (TRUE) {
[17:28:17.771]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.771]                     {
[17:28:17.771]                       inherits <- base::inherits
[17:28:17.771]                       invokeRestart <- base::invokeRestart
[17:28:17.771]                       is.null <- base::is.null
[17:28:17.771]                       muffled <- FALSE
[17:28:17.771]                       if (inherits(cond, "message")) {
[17:28:17.771]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.771]                         if (muffled) 
[17:28:17.771]                           invokeRestart("muffleMessage")
[17:28:17.771]                       }
[17:28:17.771]                       else if (inherits(cond, "warning")) {
[17:28:17.771]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.771]                         if (muffled) 
[17:28:17.771]                           invokeRestart("muffleWarning")
[17:28:17.771]                       }
[17:28:17.771]                       else if (inherits(cond, "condition")) {
[17:28:17.771]                         if (!is.null(pattern)) {
[17:28:17.771]                           computeRestarts <- base::computeRestarts
[17:28:17.771]                           grepl <- base::grepl
[17:28:17.771]                           restarts <- computeRestarts(cond)
[17:28:17.771]                           for (restart in restarts) {
[17:28:17.771]                             name <- restart$name
[17:28:17.771]                             if (is.null(name)) 
[17:28:17.771]                               next
[17:28:17.771]                             if (!grepl(pattern, name)) 
[17:28:17.771]                               next
[17:28:17.771]                             invokeRestart(restart)
[17:28:17.771]                             muffled <- TRUE
[17:28:17.771]                             break
[17:28:17.771]                           }
[17:28:17.771]                         }
[17:28:17.771]                       }
[17:28:17.771]                       invisible(muffled)
[17:28:17.771]                     }
[17:28:17.771]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.771]                   }
[17:28:17.771]                 }
[17:28:17.771]             }
[17:28:17.771]         }))
[17:28:17.771]     }, error = function(ex) {
[17:28:17.771]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.771]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.771]                 ...future.rng), started = ...future.startTime, 
[17:28:17.771]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.771]             version = "1.8"), class = "FutureResult")
[17:28:17.771]     }, finally = {
[17:28:17.771]         if (!identical(...future.workdir, getwd())) 
[17:28:17.771]             setwd(...future.workdir)
[17:28:17.771]         {
[17:28:17.771]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.771]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.771]             }
[17:28:17.771]             base::options(...future.oldOptions)
[17:28:17.771]             if (.Platform$OS.type == "windows") {
[17:28:17.771]                 old_names <- names(...future.oldEnvVars)
[17:28:17.771]                 envs <- base::Sys.getenv()
[17:28:17.771]                 names <- names(envs)
[17:28:17.771]                 common <- intersect(names, old_names)
[17:28:17.771]                 added <- setdiff(names, old_names)
[17:28:17.771]                 removed <- setdiff(old_names, names)
[17:28:17.771]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.771]                   envs[common]]
[17:28:17.771]                 NAMES <- toupper(changed)
[17:28:17.771]                 args <- list()
[17:28:17.771]                 for (kk in seq_along(NAMES)) {
[17:28:17.771]                   name <- changed[[kk]]
[17:28:17.771]                   NAME <- NAMES[[kk]]
[17:28:17.771]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.771]                     next
[17:28:17.771]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.771]                 }
[17:28:17.771]                 NAMES <- toupper(added)
[17:28:17.771]                 for (kk in seq_along(NAMES)) {
[17:28:17.771]                   name <- added[[kk]]
[17:28:17.771]                   NAME <- NAMES[[kk]]
[17:28:17.771]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.771]                     next
[17:28:17.771]                   args[[name]] <- ""
[17:28:17.771]                 }
[17:28:17.771]                 NAMES <- toupper(removed)
[17:28:17.771]                 for (kk in seq_along(NAMES)) {
[17:28:17.771]                   name <- removed[[kk]]
[17:28:17.771]                   NAME <- NAMES[[kk]]
[17:28:17.771]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.771]                     next
[17:28:17.771]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.771]                 }
[17:28:17.771]                 if (length(args) > 0) 
[17:28:17.771]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.771]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.771]             }
[17:28:17.771]             else {
[17:28:17.771]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.771]             }
[17:28:17.771]             {
[17:28:17.771]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.771]                   0L) {
[17:28:17.771]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.771]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.771]                   base::options(opts)
[17:28:17.771]                 }
[17:28:17.771]                 {
[17:28:17.771]                   {
[17:28:17.771]                     base::assign(".Random.seed", c(10407L, -1877357164L, 
[17:28:17.771]                     1962747760L, 696435396L, -889451493L, 1368934459L, 
[17:28:17.771]                     1433489833L), envir = base::globalenv(), 
[17:28:17.771]                       inherits = FALSE)
[17:28:17.771]                     NULL
[17:28:17.771]                   }
[17:28:17.771]                   options(future.plan = NULL)
[17:28:17.771]                   if (is.na(NA_character_)) 
[17:28:17.771]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.771]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.771]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.771]                     .init = FALSE)
[17:28:17.771]                 }
[17:28:17.771]             }
[17:28:17.771]         }
[17:28:17.771]     })
[17:28:17.771]     if (TRUE) {
[17:28:17.771]         base::sink(type = "output", split = FALSE)
[17:28:17.771]         if (TRUE) {
[17:28:17.771]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.771]         }
[17:28:17.771]         else {
[17:28:17.771]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.771]         }
[17:28:17.771]         base::close(...future.stdout)
[17:28:17.771]         ...future.stdout <- NULL
[17:28:17.771]     }
[17:28:17.771]     ...future.result$conditions <- ...future.conditions
[17:28:17.771]     ...future.result$finished <- base::Sys.time()
[17:28:17.771]     ...future.result
[17:28:17.771] }
[17:28:17.775] assign_globals() ...
[17:28:17.775] List of 1
[17:28:17.775]  $ x: int [1:4] 0 1 2 3
[17:28:17.775]  - attr(*, "where")=List of 1
[17:28:17.775]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.775]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.775]  - attr(*, "resolved")= logi FALSE
[17:28:17.775]  - attr(*, "total_size")= num 64
[17:28:17.775]  - attr(*, "already-done")= logi TRUE
[17:28:17.779] - copied 'x' to environment
[17:28:17.779] assign_globals() ... done
[17:28:17.779] plan(): Setting new future strategy stack:
[17:28:17.780] List of future strategies:
[17:28:17.780] 1. sequential:
[17:28:17.780]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.780]    - tweaked: FALSE
[17:28:17.780]    - call: NULL
[17:28:17.780] plan(): nbrOfWorkers() = 1
[17:28:17.781] plan(): Setting new future strategy stack:
[17:28:17.781] List of future strategies:
[17:28:17.781] 1. sequential:
[17:28:17.781]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.781]    - tweaked: FALSE
[17:28:17.781]    - call: plan(strategy)
[17:28:17.782] plan(): nbrOfWorkers() = 1
[17:28:17.782] SequentialFuture started (and completed)
[17:28:17.783] - Launch lazy future ... done
[17:28:17.783] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-316434'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x00000266738759d0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.784] getGlobalsAndPackages() ...
[17:28:17.784] Searching for globals...
[17:28:17.785] - globals found: [3] '{', 'sample', 'x'
[17:28:17.785] Searching for globals ... DONE
[17:28:17.785] Resolving globals: FALSE
[17:28:17.786] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.786] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.786] - globals: [1] 'x'
[17:28:17.787] 
[17:28:17.787] getGlobalsAndPackages() ... DONE
[17:28:17.787] run() for 'Future' ...
[17:28:17.787] - state: 'created'
[17:28:17.787] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.788] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.788] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.788]   - Field: 'label'
[17:28:17.788]   - Field: 'local'
[17:28:17.789]   - Field: 'owner'
[17:28:17.789]   - Field: 'envir'
[17:28:17.789]   - Field: 'packages'
[17:28:17.789]   - Field: 'gc'
[17:28:17.789]   - Field: 'conditions'
[17:28:17.789]   - Field: 'expr'
[17:28:17.790]   - Field: 'uuid'
[17:28:17.790]   - Field: 'seed'
[17:28:17.790]   - Field: 'version'
[17:28:17.790]   - Field: 'result'
[17:28:17.790]   - Field: 'asynchronous'
[17:28:17.790]   - Field: 'calls'
[17:28:17.791]   - Field: 'globals'
[17:28:17.791]   - Field: 'stdout'
[17:28:17.791]   - Field: 'earlySignal'
[17:28:17.791]   - Field: 'lazy'
[17:28:17.791]   - Field: 'state'
[17:28:17.791] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.792] - Launch lazy future ...
[17:28:17.792] Packages needed by the future expression (n = 0): <none>
[17:28:17.792] Packages needed by future strategies (n = 0): <none>
[17:28:17.793] {
[17:28:17.793]     {
[17:28:17.793]         {
[17:28:17.793]             ...future.startTime <- base::Sys.time()
[17:28:17.793]             {
[17:28:17.793]                 {
[17:28:17.793]                   {
[17:28:17.793]                     base::local({
[17:28:17.793]                       has_future <- base::requireNamespace("future", 
[17:28:17.793]                         quietly = TRUE)
[17:28:17.793]                       if (has_future) {
[17:28:17.793]                         ns <- base::getNamespace("future")
[17:28:17.793]                         version <- ns[[".package"]][["version"]]
[17:28:17.793]                         if (is.null(version)) 
[17:28:17.793]                           version <- utils::packageVersion("future")
[17:28:17.793]                       }
[17:28:17.793]                       else {
[17:28:17.793]                         version <- NULL
[17:28:17.793]                       }
[17:28:17.793]                       if (!has_future || version < "1.8.0") {
[17:28:17.793]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.793]                           "", base::R.version$version.string), 
[17:28:17.793]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.793]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.793]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.793]                             "release", "version")], collapse = " "), 
[17:28:17.793]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.793]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.793]                           info)
[17:28:17.793]                         info <- base::paste(info, collapse = "; ")
[17:28:17.793]                         if (!has_future) {
[17:28:17.793]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.793]                             info)
[17:28:17.793]                         }
[17:28:17.793]                         else {
[17:28:17.793]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.793]                             info, version)
[17:28:17.793]                         }
[17:28:17.793]                         base::stop(msg)
[17:28:17.793]                       }
[17:28:17.793]                     })
[17:28:17.793]                   }
[17:28:17.793]                   ...future.strategy.old <- future::plan("list")
[17:28:17.793]                   options(future.plan = NULL)
[17:28:17.793]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.793]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.793]                 }
[17:28:17.793]                 ...future.workdir <- getwd()
[17:28:17.793]             }
[17:28:17.793]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.793]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.793]         }
[17:28:17.793]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.793]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.793]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.793]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.793]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.793]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.793]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.793]             base::names(...future.oldOptions))
[17:28:17.793]     }
[17:28:17.793]     if (FALSE) {
[17:28:17.793]     }
[17:28:17.793]     else {
[17:28:17.793]         if (TRUE) {
[17:28:17.793]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.793]                 open = "w")
[17:28:17.793]         }
[17:28:17.793]         else {
[17:28:17.793]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.793]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.793]         }
[17:28:17.793]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.793]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.793]             base::sink(type = "output", split = FALSE)
[17:28:17.793]             base::close(...future.stdout)
[17:28:17.793]         }, add = TRUE)
[17:28:17.793]     }
[17:28:17.793]     ...future.frame <- base::sys.nframe()
[17:28:17.793]     ...future.conditions <- base::list()
[17:28:17.793]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.793]     if (FALSE) {
[17:28:17.793]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.793]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.793]     }
[17:28:17.793]     ...future.result <- base::tryCatch({
[17:28:17.793]         base::withCallingHandlers({
[17:28:17.793]             ...future.value <- base::withVisible(base::local({
[17:28:17.793]                 sample(x, size = 1L)
[17:28:17.793]             }))
[17:28:17.793]             future::FutureResult(value = ...future.value$value, 
[17:28:17.793]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.793]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.793]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.793]                     ...future.globalenv.names))
[17:28:17.793]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.793]         }, condition = base::local({
[17:28:17.793]             c <- base::c
[17:28:17.793]             inherits <- base::inherits
[17:28:17.793]             invokeRestart <- base::invokeRestart
[17:28:17.793]             length <- base::length
[17:28:17.793]             list <- base::list
[17:28:17.793]             seq.int <- base::seq.int
[17:28:17.793]             signalCondition <- base::signalCondition
[17:28:17.793]             sys.calls <- base::sys.calls
[17:28:17.793]             `[[` <- base::`[[`
[17:28:17.793]             `+` <- base::`+`
[17:28:17.793]             `<<-` <- base::`<<-`
[17:28:17.793]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.793]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.793]                   3L)]
[17:28:17.793]             }
[17:28:17.793]             function(cond) {
[17:28:17.793]                 is_error <- inherits(cond, "error")
[17:28:17.793]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.793]                   NULL)
[17:28:17.793]                 if (is_error) {
[17:28:17.793]                   sessionInformation <- function() {
[17:28:17.793]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.793]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.793]                       search = base::search(), system = base::Sys.info())
[17:28:17.793]                   }
[17:28:17.793]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.793]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.793]                     cond$call), session = sessionInformation(), 
[17:28:17.793]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.793]                   signalCondition(cond)
[17:28:17.793]                 }
[17:28:17.793]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.793]                 "immediateCondition"))) {
[17:28:17.793]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.793]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.793]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.793]                   if (TRUE && !signal) {
[17:28:17.793]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.793]                     {
[17:28:17.793]                       inherits <- base::inherits
[17:28:17.793]                       invokeRestart <- base::invokeRestart
[17:28:17.793]                       is.null <- base::is.null
[17:28:17.793]                       muffled <- FALSE
[17:28:17.793]                       if (inherits(cond, "message")) {
[17:28:17.793]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.793]                         if (muffled) 
[17:28:17.793]                           invokeRestart("muffleMessage")
[17:28:17.793]                       }
[17:28:17.793]                       else if (inherits(cond, "warning")) {
[17:28:17.793]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.793]                         if (muffled) 
[17:28:17.793]                           invokeRestart("muffleWarning")
[17:28:17.793]                       }
[17:28:17.793]                       else if (inherits(cond, "condition")) {
[17:28:17.793]                         if (!is.null(pattern)) {
[17:28:17.793]                           computeRestarts <- base::computeRestarts
[17:28:17.793]                           grepl <- base::grepl
[17:28:17.793]                           restarts <- computeRestarts(cond)
[17:28:17.793]                           for (restart in restarts) {
[17:28:17.793]                             name <- restart$name
[17:28:17.793]                             if (is.null(name)) 
[17:28:17.793]                               next
[17:28:17.793]                             if (!grepl(pattern, name)) 
[17:28:17.793]                               next
[17:28:17.793]                             invokeRestart(restart)
[17:28:17.793]                             muffled <- TRUE
[17:28:17.793]                             break
[17:28:17.793]                           }
[17:28:17.793]                         }
[17:28:17.793]                       }
[17:28:17.793]                       invisible(muffled)
[17:28:17.793]                     }
[17:28:17.793]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.793]                   }
[17:28:17.793]                 }
[17:28:17.793]                 else {
[17:28:17.793]                   if (TRUE) {
[17:28:17.793]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.793]                     {
[17:28:17.793]                       inherits <- base::inherits
[17:28:17.793]                       invokeRestart <- base::invokeRestart
[17:28:17.793]                       is.null <- base::is.null
[17:28:17.793]                       muffled <- FALSE
[17:28:17.793]                       if (inherits(cond, "message")) {
[17:28:17.793]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.793]                         if (muffled) 
[17:28:17.793]                           invokeRestart("muffleMessage")
[17:28:17.793]                       }
[17:28:17.793]                       else if (inherits(cond, "warning")) {
[17:28:17.793]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.793]                         if (muffled) 
[17:28:17.793]                           invokeRestart("muffleWarning")
[17:28:17.793]                       }
[17:28:17.793]                       else if (inherits(cond, "condition")) {
[17:28:17.793]                         if (!is.null(pattern)) {
[17:28:17.793]                           computeRestarts <- base::computeRestarts
[17:28:17.793]                           grepl <- base::grepl
[17:28:17.793]                           restarts <- computeRestarts(cond)
[17:28:17.793]                           for (restart in restarts) {
[17:28:17.793]                             name <- restart$name
[17:28:17.793]                             if (is.null(name)) 
[17:28:17.793]                               next
[17:28:17.793]                             if (!grepl(pattern, name)) 
[17:28:17.793]                               next
[17:28:17.793]                             invokeRestart(restart)
[17:28:17.793]                             muffled <- TRUE
[17:28:17.793]                             break
[17:28:17.793]                           }
[17:28:17.793]                         }
[17:28:17.793]                       }
[17:28:17.793]                       invisible(muffled)
[17:28:17.793]                     }
[17:28:17.793]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.793]                   }
[17:28:17.793]                 }
[17:28:17.793]             }
[17:28:17.793]         }))
[17:28:17.793]     }, error = function(ex) {
[17:28:17.793]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.793]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.793]                 ...future.rng), started = ...future.startTime, 
[17:28:17.793]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.793]             version = "1.8"), class = "FutureResult")
[17:28:17.793]     }, finally = {
[17:28:17.793]         if (!identical(...future.workdir, getwd())) 
[17:28:17.793]             setwd(...future.workdir)
[17:28:17.793]         {
[17:28:17.793]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.793]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.793]             }
[17:28:17.793]             base::options(...future.oldOptions)
[17:28:17.793]             if (.Platform$OS.type == "windows") {
[17:28:17.793]                 old_names <- names(...future.oldEnvVars)
[17:28:17.793]                 envs <- base::Sys.getenv()
[17:28:17.793]                 names <- names(envs)
[17:28:17.793]                 common <- intersect(names, old_names)
[17:28:17.793]                 added <- setdiff(names, old_names)
[17:28:17.793]                 removed <- setdiff(old_names, names)
[17:28:17.793]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.793]                   envs[common]]
[17:28:17.793]                 NAMES <- toupper(changed)
[17:28:17.793]                 args <- list()
[17:28:17.793]                 for (kk in seq_along(NAMES)) {
[17:28:17.793]                   name <- changed[[kk]]
[17:28:17.793]                   NAME <- NAMES[[kk]]
[17:28:17.793]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.793]                     next
[17:28:17.793]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.793]                 }
[17:28:17.793]                 NAMES <- toupper(added)
[17:28:17.793]                 for (kk in seq_along(NAMES)) {
[17:28:17.793]                   name <- added[[kk]]
[17:28:17.793]                   NAME <- NAMES[[kk]]
[17:28:17.793]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.793]                     next
[17:28:17.793]                   args[[name]] <- ""
[17:28:17.793]                 }
[17:28:17.793]                 NAMES <- toupper(removed)
[17:28:17.793]                 for (kk in seq_along(NAMES)) {
[17:28:17.793]                   name <- removed[[kk]]
[17:28:17.793]                   NAME <- NAMES[[kk]]
[17:28:17.793]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.793]                     next
[17:28:17.793]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.793]                 }
[17:28:17.793]                 if (length(args) > 0) 
[17:28:17.793]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.793]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.793]             }
[17:28:17.793]             else {
[17:28:17.793]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.793]             }
[17:28:17.793]             {
[17:28:17.793]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.793]                   0L) {
[17:28:17.793]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.793]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.793]                   base::options(opts)
[17:28:17.793]                 }
[17:28:17.793]                 {
[17:28:17.793]                   {
[17:28:17.793]                     base::assign(".Random.seed", c(10407L, 696435396L, 
[17:28:17.793]                     1189929049L, -976119509L, 1433489833L, -1954709644L, 
[17:28:17.793]                     -1294011257L), envir = base::globalenv(), 
[17:28:17.793]                       inherits = FALSE)
[17:28:17.793]                     NULL
[17:28:17.793]                   }
[17:28:17.793]                   options(future.plan = NULL)
[17:28:17.793]                   if (is.na(NA_character_)) 
[17:28:17.793]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.793]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.793]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.793]                     .init = FALSE)
[17:28:17.793]                 }
[17:28:17.793]             }
[17:28:17.793]         }
[17:28:17.793]     })
[17:28:17.793]     if (TRUE) {
[17:28:17.793]         base::sink(type = "output", split = FALSE)
[17:28:17.793]         if (TRUE) {
[17:28:17.793]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.793]         }
[17:28:17.793]         else {
[17:28:17.793]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.793]         }
[17:28:17.793]         base::close(...future.stdout)
[17:28:17.793]         ...future.stdout <- NULL
[17:28:17.793]     }
[17:28:17.793]     ...future.result$conditions <- ...future.conditions
[17:28:17.793]     ...future.result$finished <- base::Sys.time()
[17:28:17.793]     ...future.result
[17:28:17.793] }
[17:28:17.796] assign_globals() ...
[17:28:17.797] List of 1
[17:28:17.797]  $ x: int [1:4] 0 1 2 3
[17:28:17.797]  - attr(*, "where")=List of 1
[17:28:17.797]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.797]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.797]  - attr(*, "resolved")= logi FALSE
[17:28:17.797]  - attr(*, "total_size")= num 64
[17:28:17.797]  - attr(*, "already-done")= logi TRUE
[17:28:17.800] - copied 'x' to environment
[17:28:17.800] assign_globals() ... done
[17:28:17.800] plan(): Setting new future strategy stack:
[17:28:17.800] List of future strategies:
[17:28:17.800] 1. sequential:
[17:28:17.800]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.800]    - tweaked: FALSE
[17:28:17.800]    - call: NULL
[17:28:17.801] plan(): nbrOfWorkers() = 1
[17:28:17.802] plan(): Setting new future strategy stack:
[17:28:17.802] List of future strategies:
[17:28:17.802] 1. sequential:
[17:28:17.802]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.802]    - tweaked: FALSE
[17:28:17.802]    - call: plan(strategy)
[17:28:17.803] plan(): nbrOfWorkers() = 1
[17:28:17.803] SequentialFuture started (and completed)
[17:28:17.803] - Launch lazy future ... done
[17:28:17.803] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-987891'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x00000266738759d0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.804] getGlobalsAndPackages() ...
[17:28:17.804] Searching for globals...
[17:28:17.806] - globals found: [3] '{', 'sample', 'x'
[17:28:17.806] Searching for globals ... DONE
[17:28:17.806] Resolving globals: FALSE
[17:28:17.806] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.807] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.807] - globals: [1] 'x'
[17:28:17.807] 
[17:28:17.807] getGlobalsAndPackages() ... DONE
[17:28:17.808] run() for 'Future' ...
[17:28:17.809] - state: 'created'
[17:28:17.809] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.809] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.809] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.810]   - Field: 'label'
[17:28:17.810]   - Field: 'local'
[17:28:17.810]   - Field: 'owner'
[17:28:17.810]   - Field: 'envir'
[17:28:17.810]   - Field: 'packages'
[17:28:17.811]   - Field: 'gc'
[17:28:17.811]   - Field: 'conditions'
[17:28:17.811]   - Field: 'expr'
[17:28:17.811]   - Field: 'uuid'
[17:28:17.811]   - Field: 'seed'
[17:28:17.811]   - Field: 'version'
[17:28:17.812]   - Field: 'result'
[17:28:17.812]   - Field: 'asynchronous'
[17:28:17.812]   - Field: 'calls'
[17:28:17.812]   - Field: 'globals'
[17:28:17.812]   - Field: 'stdout'
[17:28:17.812]   - Field: 'earlySignal'
[17:28:17.813]   - Field: 'lazy'
[17:28:17.813]   - Field: 'state'
[17:28:17.813] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.813] - Launch lazy future ...
[17:28:17.813] Packages needed by the future expression (n = 0): <none>
[17:28:17.814] Packages needed by future strategies (n = 0): <none>
[17:28:17.814] {
[17:28:17.814]     {
[17:28:17.814]         {
[17:28:17.814]             ...future.startTime <- base::Sys.time()
[17:28:17.814]             {
[17:28:17.814]                 {
[17:28:17.814]                   {
[17:28:17.814]                     base::local({
[17:28:17.814]                       has_future <- base::requireNamespace("future", 
[17:28:17.814]                         quietly = TRUE)
[17:28:17.814]                       if (has_future) {
[17:28:17.814]                         ns <- base::getNamespace("future")
[17:28:17.814]                         version <- ns[[".package"]][["version"]]
[17:28:17.814]                         if (is.null(version)) 
[17:28:17.814]                           version <- utils::packageVersion("future")
[17:28:17.814]                       }
[17:28:17.814]                       else {
[17:28:17.814]                         version <- NULL
[17:28:17.814]                       }
[17:28:17.814]                       if (!has_future || version < "1.8.0") {
[17:28:17.814]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.814]                           "", base::R.version$version.string), 
[17:28:17.814]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.814]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.814]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.814]                             "release", "version")], collapse = " "), 
[17:28:17.814]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.814]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.814]                           info)
[17:28:17.814]                         info <- base::paste(info, collapse = "; ")
[17:28:17.814]                         if (!has_future) {
[17:28:17.814]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.814]                             info)
[17:28:17.814]                         }
[17:28:17.814]                         else {
[17:28:17.814]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.814]                             info, version)
[17:28:17.814]                         }
[17:28:17.814]                         base::stop(msg)
[17:28:17.814]                       }
[17:28:17.814]                     })
[17:28:17.814]                   }
[17:28:17.814]                   ...future.strategy.old <- future::plan("list")
[17:28:17.814]                   options(future.plan = NULL)
[17:28:17.814]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.814]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.814]                 }
[17:28:17.814]                 ...future.workdir <- getwd()
[17:28:17.814]             }
[17:28:17.814]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.814]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.814]         }
[17:28:17.814]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.814]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.814]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.814]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.814]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.814]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.814]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.814]             base::names(...future.oldOptions))
[17:28:17.814]     }
[17:28:17.814]     if (FALSE) {
[17:28:17.814]     }
[17:28:17.814]     else {
[17:28:17.814]         if (TRUE) {
[17:28:17.814]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.814]                 open = "w")
[17:28:17.814]         }
[17:28:17.814]         else {
[17:28:17.814]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.814]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.814]         }
[17:28:17.814]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.814]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.814]             base::sink(type = "output", split = FALSE)
[17:28:17.814]             base::close(...future.stdout)
[17:28:17.814]         }, add = TRUE)
[17:28:17.814]     }
[17:28:17.814]     ...future.frame <- base::sys.nframe()
[17:28:17.814]     ...future.conditions <- base::list()
[17:28:17.814]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.814]     if (FALSE) {
[17:28:17.814]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.814]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.814]     }
[17:28:17.814]     ...future.result <- base::tryCatch({
[17:28:17.814]         base::withCallingHandlers({
[17:28:17.814]             ...future.value <- base::withVisible(base::local({
[17:28:17.814]                 sample(x, size = 1L)
[17:28:17.814]             }))
[17:28:17.814]             future::FutureResult(value = ...future.value$value, 
[17:28:17.814]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.814]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.814]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.814]                     ...future.globalenv.names))
[17:28:17.814]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.814]         }, condition = base::local({
[17:28:17.814]             c <- base::c
[17:28:17.814]             inherits <- base::inherits
[17:28:17.814]             invokeRestart <- base::invokeRestart
[17:28:17.814]             length <- base::length
[17:28:17.814]             list <- base::list
[17:28:17.814]             seq.int <- base::seq.int
[17:28:17.814]             signalCondition <- base::signalCondition
[17:28:17.814]             sys.calls <- base::sys.calls
[17:28:17.814]             `[[` <- base::`[[`
[17:28:17.814]             `+` <- base::`+`
[17:28:17.814]             `<<-` <- base::`<<-`
[17:28:17.814]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.814]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.814]                   3L)]
[17:28:17.814]             }
[17:28:17.814]             function(cond) {
[17:28:17.814]                 is_error <- inherits(cond, "error")
[17:28:17.814]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.814]                   NULL)
[17:28:17.814]                 if (is_error) {
[17:28:17.814]                   sessionInformation <- function() {
[17:28:17.814]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.814]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.814]                       search = base::search(), system = base::Sys.info())
[17:28:17.814]                   }
[17:28:17.814]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.814]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.814]                     cond$call), session = sessionInformation(), 
[17:28:17.814]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.814]                   signalCondition(cond)
[17:28:17.814]                 }
[17:28:17.814]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.814]                 "immediateCondition"))) {
[17:28:17.814]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.814]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.814]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.814]                   if (TRUE && !signal) {
[17:28:17.814]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.814]                     {
[17:28:17.814]                       inherits <- base::inherits
[17:28:17.814]                       invokeRestart <- base::invokeRestart
[17:28:17.814]                       is.null <- base::is.null
[17:28:17.814]                       muffled <- FALSE
[17:28:17.814]                       if (inherits(cond, "message")) {
[17:28:17.814]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.814]                         if (muffled) 
[17:28:17.814]                           invokeRestart("muffleMessage")
[17:28:17.814]                       }
[17:28:17.814]                       else if (inherits(cond, "warning")) {
[17:28:17.814]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.814]                         if (muffled) 
[17:28:17.814]                           invokeRestart("muffleWarning")
[17:28:17.814]                       }
[17:28:17.814]                       else if (inherits(cond, "condition")) {
[17:28:17.814]                         if (!is.null(pattern)) {
[17:28:17.814]                           computeRestarts <- base::computeRestarts
[17:28:17.814]                           grepl <- base::grepl
[17:28:17.814]                           restarts <- computeRestarts(cond)
[17:28:17.814]                           for (restart in restarts) {
[17:28:17.814]                             name <- restart$name
[17:28:17.814]                             if (is.null(name)) 
[17:28:17.814]                               next
[17:28:17.814]                             if (!grepl(pattern, name)) 
[17:28:17.814]                               next
[17:28:17.814]                             invokeRestart(restart)
[17:28:17.814]                             muffled <- TRUE
[17:28:17.814]                             break
[17:28:17.814]                           }
[17:28:17.814]                         }
[17:28:17.814]                       }
[17:28:17.814]                       invisible(muffled)
[17:28:17.814]                     }
[17:28:17.814]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.814]                   }
[17:28:17.814]                 }
[17:28:17.814]                 else {
[17:28:17.814]                   if (TRUE) {
[17:28:17.814]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.814]                     {
[17:28:17.814]                       inherits <- base::inherits
[17:28:17.814]                       invokeRestart <- base::invokeRestart
[17:28:17.814]                       is.null <- base::is.null
[17:28:17.814]                       muffled <- FALSE
[17:28:17.814]                       if (inherits(cond, "message")) {
[17:28:17.814]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.814]                         if (muffled) 
[17:28:17.814]                           invokeRestart("muffleMessage")
[17:28:17.814]                       }
[17:28:17.814]                       else if (inherits(cond, "warning")) {
[17:28:17.814]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.814]                         if (muffled) 
[17:28:17.814]                           invokeRestart("muffleWarning")
[17:28:17.814]                       }
[17:28:17.814]                       else if (inherits(cond, "condition")) {
[17:28:17.814]                         if (!is.null(pattern)) {
[17:28:17.814]                           computeRestarts <- base::computeRestarts
[17:28:17.814]                           grepl <- base::grepl
[17:28:17.814]                           restarts <- computeRestarts(cond)
[17:28:17.814]                           for (restart in restarts) {
[17:28:17.814]                             name <- restart$name
[17:28:17.814]                             if (is.null(name)) 
[17:28:17.814]                               next
[17:28:17.814]                             if (!grepl(pattern, name)) 
[17:28:17.814]                               next
[17:28:17.814]                             invokeRestart(restart)
[17:28:17.814]                             muffled <- TRUE
[17:28:17.814]                             break
[17:28:17.814]                           }
[17:28:17.814]                         }
[17:28:17.814]                       }
[17:28:17.814]                       invisible(muffled)
[17:28:17.814]                     }
[17:28:17.814]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.814]                   }
[17:28:17.814]                 }
[17:28:17.814]             }
[17:28:17.814]         }))
[17:28:17.814]     }, error = function(ex) {
[17:28:17.814]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.814]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.814]                 ...future.rng), started = ...future.startTime, 
[17:28:17.814]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.814]             version = "1.8"), class = "FutureResult")
[17:28:17.814]     }, finally = {
[17:28:17.814]         if (!identical(...future.workdir, getwd())) 
[17:28:17.814]             setwd(...future.workdir)
[17:28:17.814]         {
[17:28:17.814]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.814]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.814]             }
[17:28:17.814]             base::options(...future.oldOptions)
[17:28:17.814]             if (.Platform$OS.type == "windows") {
[17:28:17.814]                 old_names <- names(...future.oldEnvVars)
[17:28:17.814]                 envs <- base::Sys.getenv()
[17:28:17.814]                 names <- names(envs)
[17:28:17.814]                 common <- intersect(names, old_names)
[17:28:17.814]                 added <- setdiff(names, old_names)
[17:28:17.814]                 removed <- setdiff(old_names, names)
[17:28:17.814]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.814]                   envs[common]]
[17:28:17.814]                 NAMES <- toupper(changed)
[17:28:17.814]                 args <- list()
[17:28:17.814]                 for (kk in seq_along(NAMES)) {
[17:28:17.814]                   name <- changed[[kk]]
[17:28:17.814]                   NAME <- NAMES[[kk]]
[17:28:17.814]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.814]                     next
[17:28:17.814]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.814]                 }
[17:28:17.814]                 NAMES <- toupper(added)
[17:28:17.814]                 for (kk in seq_along(NAMES)) {
[17:28:17.814]                   name <- added[[kk]]
[17:28:17.814]                   NAME <- NAMES[[kk]]
[17:28:17.814]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.814]                     next
[17:28:17.814]                   args[[name]] <- ""
[17:28:17.814]                 }
[17:28:17.814]                 NAMES <- toupper(removed)
[17:28:17.814]                 for (kk in seq_along(NAMES)) {
[17:28:17.814]                   name <- removed[[kk]]
[17:28:17.814]                   NAME <- NAMES[[kk]]
[17:28:17.814]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.814]                     next
[17:28:17.814]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.814]                 }
[17:28:17.814]                 if (length(args) > 0) 
[17:28:17.814]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.814]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.814]             }
[17:28:17.814]             else {
[17:28:17.814]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.814]             }
[17:28:17.814]             {
[17:28:17.814]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.814]                   0L) {
[17:28:17.814]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.814]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.814]                   base::options(opts)
[17:28:17.814]                 }
[17:28:17.814]                 {
[17:28:17.814]                   {
[17:28:17.814]                     base::assign(".Random.seed", c(10407L, -446836159L, 
[17:28:17.814]                     1518304212L, -1538054438L, -2128015266L, 
[17:28:17.814]                     1957638840L, 1211853682L), envir = base::globalenv(), 
[17:28:17.814]                       inherits = FALSE)
[17:28:17.814]                     NULL
[17:28:17.814]                   }
[17:28:17.814]                   options(future.plan = NULL)
[17:28:17.814]                   if (is.na(NA_character_)) 
[17:28:17.814]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.814]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.814]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.814]                     .init = FALSE)
[17:28:17.814]                 }
[17:28:17.814]             }
[17:28:17.814]         }
[17:28:17.814]     })
[17:28:17.814]     if (TRUE) {
[17:28:17.814]         base::sink(type = "output", split = FALSE)
[17:28:17.814]         if (TRUE) {
[17:28:17.814]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.814]         }
[17:28:17.814]         else {
[17:28:17.814]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.814]         }
[17:28:17.814]         base::close(...future.stdout)
[17:28:17.814]         ...future.stdout <- NULL
[17:28:17.814]     }
[17:28:17.814]     ...future.result$conditions <- ...future.conditions
[17:28:17.814]     ...future.result$finished <- base::Sys.time()
[17:28:17.814]     ...future.result
[17:28:17.814] }
[17:28:17.818] assign_globals() ...
[17:28:17.818] List of 1
[17:28:17.818]  $ x: int [1:4] 0 1 2 3
[17:28:17.818]  - attr(*, "where")=List of 1
[17:28:17.818]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.818]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.818]  - attr(*, "resolved")= logi FALSE
[17:28:17.818]  - attr(*, "total_size")= num 64
[17:28:17.818]  - attr(*, "already-done")= logi TRUE
[17:28:17.821] - copied 'x' to environment
[17:28:17.821] assign_globals() ... done
[17:28:17.821] plan(): Setting new future strategy stack:
[17:28:17.822] List of future strategies:
[17:28:17.822] 1. sequential:
[17:28:17.822]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.822]    - tweaked: FALSE
[17:28:17.822]    - call: NULL
[17:28:17.822] plan(): nbrOfWorkers() = 1
[17:28:17.823] plan(): Setting new future strategy stack:
[17:28:17.823] List of future strategies:
[17:28:17.823] 1. sequential:
[17:28:17.823]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.823]    - tweaked: FALSE
[17:28:17.823]    - call: plan(strategy)
[17:28:17.824] plan(): nbrOfWorkers() = 1
[17:28:17.824] SequentialFuture started (and completed)
[17:28:17.824] - Launch lazy future ... done
[17:28:17.825] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-23576'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x00000266738759d0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.826] getGlobalsAndPackages() ...
[17:28:17.826] Searching for globals...
[17:28:17.827] - globals found: [3] '{', 'sample', 'x'
[17:28:17.827] Searching for globals ... DONE
[17:28:17.827] Resolving globals: FALSE
[17:28:17.828] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.828] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.828] - globals: [1] 'x'
[17:28:17.829] 
[17:28:17.829] getGlobalsAndPackages() ... DONE
[17:28:17.829] run() for 'Future' ...
[17:28:17.829] - state: 'created'
[17:28:17.829] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.830] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.830] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.830]   - Field: 'label'
[17:28:17.830]   - Field: 'local'
[17:28:17.830]   - Field: 'owner'
[17:28:17.831]   - Field: 'envir'
[17:28:17.831]   - Field: 'packages'
[17:28:17.831]   - Field: 'gc'
[17:28:17.831]   - Field: 'conditions'
[17:28:17.831]   - Field: 'expr'
[17:28:17.832]   - Field: 'uuid'
[17:28:17.832]   - Field: 'seed'
[17:28:17.832]   - Field: 'version'
[17:28:17.832]   - Field: 'result'
[17:28:17.832]   - Field: 'asynchronous'
[17:28:17.832]   - Field: 'calls'
[17:28:17.833]   - Field: 'globals'
[17:28:17.833]   - Field: 'stdout'
[17:28:17.833]   - Field: 'earlySignal'
[17:28:17.833]   - Field: 'lazy'
[17:28:17.833]   - Field: 'state'
[17:28:17.833] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.834] - Launch lazy future ...
[17:28:17.834] Packages needed by the future expression (n = 0): <none>
[17:28:17.834] Packages needed by future strategies (n = 0): <none>
[17:28:17.835] {
[17:28:17.835]     {
[17:28:17.835]         {
[17:28:17.835]             ...future.startTime <- base::Sys.time()
[17:28:17.835]             {
[17:28:17.835]                 {
[17:28:17.835]                   {
[17:28:17.835]                     base::local({
[17:28:17.835]                       has_future <- base::requireNamespace("future", 
[17:28:17.835]                         quietly = TRUE)
[17:28:17.835]                       if (has_future) {
[17:28:17.835]                         ns <- base::getNamespace("future")
[17:28:17.835]                         version <- ns[[".package"]][["version"]]
[17:28:17.835]                         if (is.null(version)) 
[17:28:17.835]                           version <- utils::packageVersion("future")
[17:28:17.835]                       }
[17:28:17.835]                       else {
[17:28:17.835]                         version <- NULL
[17:28:17.835]                       }
[17:28:17.835]                       if (!has_future || version < "1.8.0") {
[17:28:17.835]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.835]                           "", base::R.version$version.string), 
[17:28:17.835]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.835]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.835]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.835]                             "release", "version")], collapse = " "), 
[17:28:17.835]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.835]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.835]                           info)
[17:28:17.835]                         info <- base::paste(info, collapse = "; ")
[17:28:17.835]                         if (!has_future) {
[17:28:17.835]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.835]                             info)
[17:28:17.835]                         }
[17:28:17.835]                         else {
[17:28:17.835]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.835]                             info, version)
[17:28:17.835]                         }
[17:28:17.835]                         base::stop(msg)
[17:28:17.835]                       }
[17:28:17.835]                     })
[17:28:17.835]                   }
[17:28:17.835]                   ...future.strategy.old <- future::plan("list")
[17:28:17.835]                   options(future.plan = NULL)
[17:28:17.835]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.835]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.835]                 }
[17:28:17.835]                 ...future.workdir <- getwd()
[17:28:17.835]             }
[17:28:17.835]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.835]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.835]         }
[17:28:17.835]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.835]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.835]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.835]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.835]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.835]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.835]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.835]             base::names(...future.oldOptions))
[17:28:17.835]     }
[17:28:17.835]     if (FALSE) {
[17:28:17.835]     }
[17:28:17.835]     else {
[17:28:17.835]         if (TRUE) {
[17:28:17.835]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.835]                 open = "w")
[17:28:17.835]         }
[17:28:17.835]         else {
[17:28:17.835]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.835]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.835]         }
[17:28:17.835]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.835]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.835]             base::sink(type = "output", split = FALSE)
[17:28:17.835]             base::close(...future.stdout)
[17:28:17.835]         }, add = TRUE)
[17:28:17.835]     }
[17:28:17.835]     ...future.frame <- base::sys.nframe()
[17:28:17.835]     ...future.conditions <- base::list()
[17:28:17.835]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.835]     if (FALSE) {
[17:28:17.835]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.835]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.835]     }
[17:28:17.835]     ...future.result <- base::tryCatch({
[17:28:17.835]         base::withCallingHandlers({
[17:28:17.835]             ...future.value <- base::withVisible(base::local({
[17:28:17.835]                 sample(x, size = 1L)
[17:28:17.835]             }))
[17:28:17.835]             future::FutureResult(value = ...future.value$value, 
[17:28:17.835]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.835]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.835]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.835]                     ...future.globalenv.names))
[17:28:17.835]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.835]         }, condition = base::local({
[17:28:17.835]             c <- base::c
[17:28:17.835]             inherits <- base::inherits
[17:28:17.835]             invokeRestart <- base::invokeRestart
[17:28:17.835]             length <- base::length
[17:28:17.835]             list <- base::list
[17:28:17.835]             seq.int <- base::seq.int
[17:28:17.835]             signalCondition <- base::signalCondition
[17:28:17.835]             sys.calls <- base::sys.calls
[17:28:17.835]             `[[` <- base::`[[`
[17:28:17.835]             `+` <- base::`+`
[17:28:17.835]             `<<-` <- base::`<<-`
[17:28:17.835]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.835]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.835]                   3L)]
[17:28:17.835]             }
[17:28:17.835]             function(cond) {
[17:28:17.835]                 is_error <- inherits(cond, "error")
[17:28:17.835]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.835]                   NULL)
[17:28:17.835]                 if (is_error) {
[17:28:17.835]                   sessionInformation <- function() {
[17:28:17.835]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.835]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.835]                       search = base::search(), system = base::Sys.info())
[17:28:17.835]                   }
[17:28:17.835]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.835]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.835]                     cond$call), session = sessionInformation(), 
[17:28:17.835]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.835]                   signalCondition(cond)
[17:28:17.835]                 }
[17:28:17.835]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.835]                 "immediateCondition"))) {
[17:28:17.835]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.835]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.835]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.835]                   if (TRUE && !signal) {
[17:28:17.835]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.835]                     {
[17:28:17.835]                       inherits <- base::inherits
[17:28:17.835]                       invokeRestart <- base::invokeRestart
[17:28:17.835]                       is.null <- base::is.null
[17:28:17.835]                       muffled <- FALSE
[17:28:17.835]                       if (inherits(cond, "message")) {
[17:28:17.835]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.835]                         if (muffled) 
[17:28:17.835]                           invokeRestart("muffleMessage")
[17:28:17.835]                       }
[17:28:17.835]                       else if (inherits(cond, "warning")) {
[17:28:17.835]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.835]                         if (muffled) 
[17:28:17.835]                           invokeRestart("muffleWarning")
[17:28:17.835]                       }
[17:28:17.835]                       else if (inherits(cond, "condition")) {
[17:28:17.835]                         if (!is.null(pattern)) {
[17:28:17.835]                           computeRestarts <- base::computeRestarts
[17:28:17.835]                           grepl <- base::grepl
[17:28:17.835]                           restarts <- computeRestarts(cond)
[17:28:17.835]                           for (restart in restarts) {
[17:28:17.835]                             name <- restart$name
[17:28:17.835]                             if (is.null(name)) 
[17:28:17.835]                               next
[17:28:17.835]                             if (!grepl(pattern, name)) 
[17:28:17.835]                               next
[17:28:17.835]                             invokeRestart(restart)
[17:28:17.835]                             muffled <- TRUE
[17:28:17.835]                             break
[17:28:17.835]                           }
[17:28:17.835]                         }
[17:28:17.835]                       }
[17:28:17.835]                       invisible(muffled)
[17:28:17.835]                     }
[17:28:17.835]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.835]                   }
[17:28:17.835]                 }
[17:28:17.835]                 else {
[17:28:17.835]                   if (TRUE) {
[17:28:17.835]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.835]                     {
[17:28:17.835]                       inherits <- base::inherits
[17:28:17.835]                       invokeRestart <- base::invokeRestart
[17:28:17.835]                       is.null <- base::is.null
[17:28:17.835]                       muffled <- FALSE
[17:28:17.835]                       if (inherits(cond, "message")) {
[17:28:17.835]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.835]                         if (muffled) 
[17:28:17.835]                           invokeRestart("muffleMessage")
[17:28:17.835]                       }
[17:28:17.835]                       else if (inherits(cond, "warning")) {
[17:28:17.835]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.835]                         if (muffled) 
[17:28:17.835]                           invokeRestart("muffleWarning")
[17:28:17.835]                       }
[17:28:17.835]                       else if (inherits(cond, "condition")) {
[17:28:17.835]                         if (!is.null(pattern)) {
[17:28:17.835]                           computeRestarts <- base::computeRestarts
[17:28:17.835]                           grepl <- base::grepl
[17:28:17.835]                           restarts <- computeRestarts(cond)
[17:28:17.835]                           for (restart in restarts) {
[17:28:17.835]                             name <- restart$name
[17:28:17.835]                             if (is.null(name)) 
[17:28:17.835]                               next
[17:28:17.835]                             if (!grepl(pattern, name)) 
[17:28:17.835]                               next
[17:28:17.835]                             invokeRestart(restart)
[17:28:17.835]                             muffled <- TRUE
[17:28:17.835]                             break
[17:28:17.835]                           }
[17:28:17.835]                         }
[17:28:17.835]                       }
[17:28:17.835]                       invisible(muffled)
[17:28:17.835]                     }
[17:28:17.835]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.835]                   }
[17:28:17.835]                 }
[17:28:17.835]             }
[17:28:17.835]         }))
[17:28:17.835]     }, error = function(ex) {
[17:28:17.835]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.835]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.835]                 ...future.rng), started = ...future.startTime, 
[17:28:17.835]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.835]             version = "1.8"), class = "FutureResult")
[17:28:17.835]     }, finally = {
[17:28:17.835]         if (!identical(...future.workdir, getwd())) 
[17:28:17.835]             setwd(...future.workdir)
[17:28:17.835]         {
[17:28:17.835]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.835]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.835]             }
[17:28:17.835]             base::options(...future.oldOptions)
[17:28:17.835]             if (.Platform$OS.type == "windows") {
[17:28:17.835]                 old_names <- names(...future.oldEnvVars)
[17:28:17.835]                 envs <- base::Sys.getenv()
[17:28:17.835]                 names <- names(envs)
[17:28:17.835]                 common <- intersect(names, old_names)
[17:28:17.835]                 added <- setdiff(names, old_names)
[17:28:17.835]                 removed <- setdiff(old_names, names)
[17:28:17.835]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.835]                   envs[common]]
[17:28:17.835]                 NAMES <- toupper(changed)
[17:28:17.835]                 args <- list()
[17:28:17.835]                 for (kk in seq_along(NAMES)) {
[17:28:17.835]                   name <- changed[[kk]]
[17:28:17.835]                   NAME <- NAMES[[kk]]
[17:28:17.835]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.835]                     next
[17:28:17.835]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.835]                 }
[17:28:17.835]                 NAMES <- toupper(added)
[17:28:17.835]                 for (kk in seq_along(NAMES)) {
[17:28:17.835]                   name <- added[[kk]]
[17:28:17.835]                   NAME <- NAMES[[kk]]
[17:28:17.835]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.835]                     next
[17:28:17.835]                   args[[name]] <- ""
[17:28:17.835]                 }
[17:28:17.835]                 NAMES <- toupper(removed)
[17:28:17.835]                 for (kk in seq_along(NAMES)) {
[17:28:17.835]                   name <- removed[[kk]]
[17:28:17.835]                   NAME <- NAMES[[kk]]
[17:28:17.835]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.835]                     next
[17:28:17.835]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.835]                 }
[17:28:17.835]                 if (length(args) > 0) 
[17:28:17.835]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.835]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.835]             }
[17:28:17.835]             else {
[17:28:17.835]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.835]             }
[17:28:17.835]             {
[17:28:17.835]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.835]                   0L) {
[17:28:17.835]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.835]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.835]                   base::options(opts)
[17:28:17.835]                 }
[17:28:17.835]                 {
[17:28:17.835]                   {
[17:28:17.835]                     base::assign(".Random.seed", c(10407L, -1538054438L, 
[17:28:17.835]                     958671146L, -1312820442L, 1211853682L, 876515677L, 
[17:28:17.835]                     4105284L), envir = base::globalenv(), inherits = FALSE)
[17:28:17.835]                     NULL
[17:28:17.835]                   }
[17:28:17.835]                   options(future.plan = NULL)
[17:28:17.835]                   if (is.na(NA_character_)) 
[17:28:17.835]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.835]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.835]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.835]                     .init = FALSE)
[17:28:17.835]                 }
[17:28:17.835]             }
[17:28:17.835]         }
[17:28:17.835]     })
[17:28:17.835]     if (TRUE) {
[17:28:17.835]         base::sink(type = "output", split = FALSE)
[17:28:17.835]         if (TRUE) {
[17:28:17.835]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.835]         }
[17:28:17.835]         else {
[17:28:17.835]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.835]         }
[17:28:17.835]         base::close(...future.stdout)
[17:28:17.835]         ...future.stdout <- NULL
[17:28:17.835]     }
[17:28:17.835]     ...future.result$conditions <- ...future.conditions
[17:28:17.835]     ...future.result$finished <- base::Sys.time()
[17:28:17.835]     ...future.result
[17:28:17.835] }
[17:28:17.838] assign_globals() ...
[17:28:17.838] List of 1
[17:28:17.838]  $ x: int [1:4] 0 1 2 3
[17:28:17.838]  - attr(*, "where")=List of 1
[17:28:17.838]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.838]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.838]  - attr(*, "resolved")= logi FALSE
[17:28:17.838]  - attr(*, "total_size")= num 64
[17:28:17.838]  - attr(*, "already-done")= logi TRUE
[17:28:17.841] - copied 'x' to environment
[17:28:17.841] assign_globals() ... done
[17:28:17.842] plan(): Setting new future strategy stack:
[17:28:17.842] List of future strategies:
[17:28:17.842] 1. sequential:
[17:28:17.842]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.842]    - tweaked: FALSE
[17:28:17.842]    - call: NULL
[17:28:17.843] plan(): nbrOfWorkers() = 1
[17:28:17.845] plan(): Setting new future strategy stack:
[17:28:17.845] List of future strategies:
[17:28:17.845] 1. sequential:
[17:28:17.845]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.845]    - tweaked: FALSE
[17:28:17.845]    - call: plan(strategy)
[17:28:17.845] plan(): nbrOfWorkers() = 1
[17:28:17.846] SequentialFuture started (and completed)
[17:28:17.846] - Launch lazy future ... done
[17:28:17.846] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-373122'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x00000266738759d0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.847] resolve() on list ...
[17:28:17.847]  recursive: 0
[17:28:17.847]  length: 4
[17:28:17.848] 
[17:28:17.848] resolved() for 'SequentialFuture' ...
[17:28:17.848] - state: 'finished'
[17:28:17.848] - run: TRUE
[17:28:17.848] - result: 'FutureResult'
[17:28:17.848] resolved() for 'SequentialFuture' ... done
[17:28:17.849] Future #1
[17:28:17.849] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:28:17.849] - nx: 4
[17:28:17.849] - relay: TRUE
[17:28:17.850] - stdout: TRUE
[17:28:17.850] - signal: TRUE
[17:28:17.850] - resignal: FALSE
[17:28:17.850] - force: TRUE
[17:28:17.850] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.850] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.850]  - until=1
[17:28:17.851]  - relaying element #1
[17:28:17.851] signalConditions() ...
[17:28:17.851]  - include = 'immediateCondition'
[17:28:17.851]  - exclude = 
[17:28:17.851]  - resignal = FALSE
[17:28:17.851]  - Number of conditions: 1
[17:28:17.852] signalConditions() ... done
[17:28:17.852] signalConditions() ...
[17:28:17.852]  - include = 'immediateCondition'
[17:28:17.852]  - exclude = 
[17:28:17.852]  - resignal = FALSE
[17:28:17.852]  - Number of conditions: 1
[17:28:17.853] signalConditions() ... done
[17:28:17.853] signalConditions() ...
[17:28:17.853]  - include = 'condition'
[17:28:17.853]  - exclude = 'immediateCondition'
[17:28:17.853]  - resignal = TRUE
[17:28:17.853]  - Number of conditions: 1
[17:28:17.854]  - Condition #1: 'RngFutureError', 'FutureError', 'error', 'RngFutureCondition', 'FutureCondition', 'condition'
[17:28:17.854] signalConditions() ... done
[17:28:17.854] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.854] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.854] signalConditionsASAP(SequentialFuture, pos=1) ... done
<RngFutureError: UNRELIABLE VALUE: Future ('fsample_1-316434') 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: 6917a563-c222-6703-5584-d3ab15dd6039


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

DEBUG: END TROUBLESHOOTING HELP
[17:28:17.855] getGlobalsAndPackages() ...
[17:28:17.856] Searching for globals...
[17:28:17.857] - globals found: [3] '{', 'sample', 'x'
[17:28:17.857] Searching for globals ... DONE
[17:28:17.857] Resolving globals: FALSE
[17:28:17.858] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.858] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.858] - globals: [1] 'x'
[17:28:17.858] 
[17:28:17.859] getGlobalsAndPackages() ... DONE
[17:28:17.859] run() for 'Future' ...
[17:28:17.859] - state: 'created'
[17:28:17.859] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.860] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.860] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.860]   - Field: 'label'
[17:28:17.860]   - Field: 'local'
[17:28:17.860]   - Field: 'owner'
[17:28:17.860]   - Field: 'envir'
[17:28:17.861]   - Field: 'packages'
[17:28:17.861]   - Field: 'gc'
[17:28:17.861]   - Field: 'conditions'
[17:28:17.861]   - Field: 'expr'
[17:28:17.861]   - Field: 'uuid'
[17:28:17.862]   - Field: 'seed'
[17:28:17.862]   - Field: 'version'
[17:28:17.862]   - Field: 'result'
[17:28:17.862]   - Field: 'asynchronous'
[17:28:17.862]   - Field: 'calls'
[17:28:17.862]   - Field: 'globals'
[17:28:17.863]   - Field: 'stdout'
[17:28:17.863]   - Field: 'earlySignal'
[17:28:17.863]   - Field: 'lazy'
[17:28:17.863]   - Field: 'state'
[17:28:17.863] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.863] - Launch lazy future ...
[17:28:17.864] Packages needed by the future expression (n = 0): <none>
[17:28:17.864] Packages needed by future strategies (n = 0): <none>
[17:28:17.864] {
[17:28:17.864]     {
[17:28:17.864]         {
[17:28:17.864]             ...future.startTime <- base::Sys.time()
[17:28:17.864]             {
[17:28:17.864]                 {
[17:28:17.864]                   {
[17:28:17.864]                     base::local({
[17:28:17.864]                       has_future <- base::requireNamespace("future", 
[17:28:17.864]                         quietly = TRUE)
[17:28:17.864]                       if (has_future) {
[17:28:17.864]                         ns <- base::getNamespace("future")
[17:28:17.864]                         version <- ns[[".package"]][["version"]]
[17:28:17.864]                         if (is.null(version)) 
[17:28:17.864]                           version <- utils::packageVersion("future")
[17:28:17.864]                       }
[17:28:17.864]                       else {
[17:28:17.864]                         version <- NULL
[17:28:17.864]                       }
[17:28:17.864]                       if (!has_future || version < "1.8.0") {
[17:28:17.864]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.864]                           "", base::R.version$version.string), 
[17:28:17.864]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.864]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.864]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.864]                             "release", "version")], collapse = " "), 
[17:28:17.864]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.864]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.864]                           info)
[17:28:17.864]                         info <- base::paste(info, collapse = "; ")
[17:28:17.864]                         if (!has_future) {
[17:28:17.864]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.864]                             info)
[17:28:17.864]                         }
[17:28:17.864]                         else {
[17:28:17.864]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.864]                             info, version)
[17:28:17.864]                         }
[17:28:17.864]                         base::stop(msg)
[17:28:17.864]                       }
[17:28:17.864]                     })
[17:28:17.864]                   }
[17:28:17.864]                   ...future.strategy.old <- future::plan("list")
[17:28:17.864]                   options(future.plan = NULL)
[17:28:17.864]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.864]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.864]                 }
[17:28:17.864]                 ...future.workdir <- getwd()
[17:28:17.864]             }
[17:28:17.864]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.864]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.864]         }
[17:28:17.864]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.864]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.864]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.864]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.864]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.864]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.864]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.864]             base::names(...future.oldOptions))
[17:28:17.864]     }
[17:28:17.864]     if (FALSE) {
[17:28:17.864]     }
[17:28:17.864]     else {
[17:28:17.864]         if (TRUE) {
[17:28:17.864]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.864]                 open = "w")
[17:28:17.864]         }
[17:28:17.864]         else {
[17:28:17.864]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.864]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.864]         }
[17:28:17.864]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.864]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.864]             base::sink(type = "output", split = FALSE)
[17:28:17.864]             base::close(...future.stdout)
[17:28:17.864]         }, add = TRUE)
[17:28:17.864]     }
[17:28:17.864]     ...future.frame <- base::sys.nframe()
[17:28:17.864]     ...future.conditions <- base::list()
[17:28:17.864]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.864]     if (FALSE) {
[17:28:17.864]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.864]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.864]     }
[17:28:17.864]     ...future.result <- base::tryCatch({
[17:28:17.864]         base::withCallingHandlers({
[17:28:17.864]             ...future.value <- base::withVisible(base::local({
[17:28:17.864]                 sample(x, size = 1L)
[17:28:17.864]             }))
[17:28:17.864]             future::FutureResult(value = ...future.value$value, 
[17:28:17.864]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.864]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.864]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.864]                     ...future.globalenv.names))
[17:28:17.864]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.864]         }, condition = base::local({
[17:28:17.864]             c <- base::c
[17:28:17.864]             inherits <- base::inherits
[17:28:17.864]             invokeRestart <- base::invokeRestart
[17:28:17.864]             length <- base::length
[17:28:17.864]             list <- base::list
[17:28:17.864]             seq.int <- base::seq.int
[17:28:17.864]             signalCondition <- base::signalCondition
[17:28:17.864]             sys.calls <- base::sys.calls
[17:28:17.864]             `[[` <- base::`[[`
[17:28:17.864]             `+` <- base::`+`
[17:28:17.864]             `<<-` <- base::`<<-`
[17:28:17.864]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.864]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.864]                   3L)]
[17:28:17.864]             }
[17:28:17.864]             function(cond) {
[17:28:17.864]                 is_error <- inherits(cond, "error")
[17:28:17.864]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.864]                   NULL)
[17:28:17.864]                 if (is_error) {
[17:28:17.864]                   sessionInformation <- function() {
[17:28:17.864]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.864]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.864]                       search = base::search(), system = base::Sys.info())
[17:28:17.864]                   }
[17:28:17.864]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.864]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.864]                     cond$call), session = sessionInformation(), 
[17:28:17.864]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.864]                   signalCondition(cond)
[17:28:17.864]                 }
[17:28:17.864]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.864]                 "immediateCondition"))) {
[17:28:17.864]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.864]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.864]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.864]                   if (TRUE && !signal) {
[17:28:17.864]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.864]                     {
[17:28:17.864]                       inherits <- base::inherits
[17:28:17.864]                       invokeRestart <- base::invokeRestart
[17:28:17.864]                       is.null <- base::is.null
[17:28:17.864]                       muffled <- FALSE
[17:28:17.864]                       if (inherits(cond, "message")) {
[17:28:17.864]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.864]                         if (muffled) 
[17:28:17.864]                           invokeRestart("muffleMessage")
[17:28:17.864]                       }
[17:28:17.864]                       else if (inherits(cond, "warning")) {
[17:28:17.864]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.864]                         if (muffled) 
[17:28:17.864]                           invokeRestart("muffleWarning")
[17:28:17.864]                       }
[17:28:17.864]                       else if (inherits(cond, "condition")) {
[17:28:17.864]                         if (!is.null(pattern)) {
[17:28:17.864]                           computeRestarts <- base::computeRestarts
[17:28:17.864]                           grepl <- base::grepl
[17:28:17.864]                           restarts <- computeRestarts(cond)
[17:28:17.864]                           for (restart in restarts) {
[17:28:17.864]                             name <- restart$name
[17:28:17.864]                             if (is.null(name)) 
[17:28:17.864]                               next
[17:28:17.864]                             if (!grepl(pattern, name)) 
[17:28:17.864]                               next
[17:28:17.864]                             invokeRestart(restart)
[17:28:17.864]                             muffled <- TRUE
[17:28:17.864]                             break
[17:28:17.864]                           }
[17:28:17.864]                         }
[17:28:17.864]                       }
[17:28:17.864]                       invisible(muffled)
[17:28:17.864]                     }
[17:28:17.864]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.864]                   }
[17:28:17.864]                 }
[17:28:17.864]                 else {
[17:28:17.864]                   if (TRUE) {
[17:28:17.864]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.864]                     {
[17:28:17.864]                       inherits <- base::inherits
[17:28:17.864]                       invokeRestart <- base::invokeRestart
[17:28:17.864]                       is.null <- base::is.null
[17:28:17.864]                       muffled <- FALSE
[17:28:17.864]                       if (inherits(cond, "message")) {
[17:28:17.864]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.864]                         if (muffled) 
[17:28:17.864]                           invokeRestart("muffleMessage")
[17:28:17.864]                       }
[17:28:17.864]                       else if (inherits(cond, "warning")) {
[17:28:17.864]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.864]                         if (muffled) 
[17:28:17.864]                           invokeRestart("muffleWarning")
[17:28:17.864]                       }
[17:28:17.864]                       else if (inherits(cond, "condition")) {
[17:28:17.864]                         if (!is.null(pattern)) {
[17:28:17.864]                           computeRestarts <- base::computeRestarts
[17:28:17.864]                           grepl <- base::grepl
[17:28:17.864]                           restarts <- computeRestarts(cond)
[17:28:17.864]                           for (restart in restarts) {
[17:28:17.864]                             name <- restart$name
[17:28:17.864]                             if (is.null(name)) 
[17:28:17.864]                               next
[17:28:17.864]                             if (!grepl(pattern, name)) 
[17:28:17.864]                               next
[17:28:17.864]                             invokeRestart(restart)
[17:28:17.864]                             muffled <- TRUE
[17:28:17.864]                             break
[17:28:17.864]                           }
[17:28:17.864]                         }
[17:28:17.864]                       }
[17:28:17.864]                       invisible(muffled)
[17:28:17.864]                     }
[17:28:17.864]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.864]                   }
[17:28:17.864]                 }
[17:28:17.864]             }
[17:28:17.864]         }))
[17:28:17.864]     }, error = function(ex) {
[17:28:17.864]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.864]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.864]                 ...future.rng), started = ...future.startTime, 
[17:28:17.864]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.864]             version = "1.8"), class = "FutureResult")
[17:28:17.864]     }, finally = {
[17:28:17.864]         if (!identical(...future.workdir, getwd())) 
[17:28:17.864]             setwd(...future.workdir)
[17:28:17.864]         {
[17:28:17.864]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.864]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.864]             }
[17:28:17.864]             base::options(...future.oldOptions)
[17:28:17.864]             if (.Platform$OS.type == "windows") {
[17:28:17.864]                 old_names <- names(...future.oldEnvVars)
[17:28:17.864]                 envs <- base::Sys.getenv()
[17:28:17.864]                 names <- names(envs)
[17:28:17.864]                 common <- intersect(names, old_names)
[17:28:17.864]                 added <- setdiff(names, old_names)
[17:28:17.864]                 removed <- setdiff(old_names, names)
[17:28:17.864]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.864]                   envs[common]]
[17:28:17.864]                 NAMES <- toupper(changed)
[17:28:17.864]                 args <- list()
[17:28:17.864]                 for (kk in seq_along(NAMES)) {
[17:28:17.864]                   name <- changed[[kk]]
[17:28:17.864]                   NAME <- NAMES[[kk]]
[17:28:17.864]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.864]                     next
[17:28:17.864]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.864]                 }
[17:28:17.864]                 NAMES <- toupper(added)
[17:28:17.864]                 for (kk in seq_along(NAMES)) {
[17:28:17.864]                   name <- added[[kk]]
[17:28:17.864]                   NAME <- NAMES[[kk]]
[17:28:17.864]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.864]                     next
[17:28:17.864]                   args[[name]] <- ""
[17:28:17.864]                 }
[17:28:17.864]                 NAMES <- toupper(removed)
[17:28:17.864]                 for (kk in seq_along(NAMES)) {
[17:28:17.864]                   name <- removed[[kk]]
[17:28:17.864]                   NAME <- NAMES[[kk]]
[17:28:17.864]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.864]                     next
[17:28:17.864]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.864]                 }
[17:28:17.864]                 if (length(args) > 0) 
[17:28:17.864]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.864]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.864]             }
[17:28:17.864]             else {
[17:28:17.864]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.864]             }
[17:28:17.864]             {
[17:28:17.864]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.864]                   0L) {
[17:28:17.864]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.864]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.864]                   base::options(opts)
[17:28:17.864]                 }
[17:28:17.864]                 {
[17:28:17.864]                   {
[17:28:17.864]                     base::assign(".Random.seed", c(10407L, -1068574288L, 
[17:28:17.864]                     -1056568618L, 817755046L, 914010983L, 859132510L, 
[17:28:17.864]                     -1013881922L), envir = base::globalenv(), 
[17:28:17.864]                       inherits = FALSE)
[17:28:17.864]                     NULL
[17:28:17.864]                   }
[17:28:17.864]                   options(future.plan = NULL)
[17:28:17.864]                   if (is.na(NA_character_)) 
[17:28:17.864]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.864]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.864]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.864]                     .init = FALSE)
[17:28:17.864]                 }
[17:28:17.864]             }
[17:28:17.864]         }
[17:28:17.864]     })
[17:28:17.864]     if (TRUE) {
[17:28:17.864]         base::sink(type = "output", split = FALSE)
[17:28:17.864]         if (TRUE) {
[17:28:17.864]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.864]         }
[17:28:17.864]         else {
[17:28:17.864]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.864]         }
[17:28:17.864]         base::close(...future.stdout)
[17:28:17.864]         ...future.stdout <- NULL
[17:28:17.864]     }
[17:28:17.864]     ...future.result$conditions <- ...future.conditions
[17:28:17.864]     ...future.result$finished <- base::Sys.time()
[17:28:17.864]     ...future.result
[17:28:17.864] }
[17:28:17.868] assign_globals() ...
[17:28:17.868] List of 1
[17:28:17.868]  $ x: int [1:4] 0 1 2 3
[17:28:17.868]  - attr(*, "where")=List of 1
[17:28:17.868]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.868]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.868]  - attr(*, "resolved")= logi FALSE
[17:28:17.868]  - attr(*, "total_size")= num 64
[17:28:17.868]  - attr(*, "already-done")= logi TRUE
[17:28:17.871] - copied 'x' to environment
[17:28:17.871] assign_globals() ... done
[17:28:17.872] plan(): Setting new future strategy stack:
[17:28:17.872] List of future strategies:
[17:28:17.872] 1. sequential:
[17:28:17.872]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.872]    - tweaked: FALSE
[17:28:17.872]    - call: NULL
[17:28:17.872] plan(): nbrOfWorkers() = 1
[17:28:17.874] plan(): Setting new future strategy stack:
[17:28:17.874] List of future strategies:
[17:28:17.874] 1. sequential:
[17:28:17.874]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.874]    - tweaked: FALSE
[17:28:17.874]    - call: plan(strategy)
[17:28:17.874] plan(): nbrOfWorkers() = 1
[17:28:17.875] SequentialFuture started (and completed)
[17:28:17.875] - Launch lazy future ... done
[17:28:17.875] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-27949'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x0000026671179538
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.876] getGlobalsAndPackages() ...
[17:28:17.876] Searching for globals...
[17:28:17.878] - globals found: [3] '{', 'sample', 'x'
[17:28:17.878] Searching for globals ... DONE
[17:28:17.878] Resolving globals: FALSE
[17:28:17.879] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.879] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.880] - globals: [1] 'x'
[17:28:17.880] 
[17:28:17.880] getGlobalsAndPackages() ... DONE
[17:28:17.880] run() for 'Future' ...
[17:28:17.880] - state: 'created'
[17:28:17.881] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.881] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.881] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.881]   - Field: 'label'
[17:28:17.882]   - Field: 'local'
[17:28:17.882]   - Field: 'owner'
[17:28:17.882]   - Field: 'envir'
[17:28:17.882]   - Field: 'packages'
[17:28:17.882]   - Field: 'gc'
[17:28:17.882]   - Field: 'conditions'
[17:28:17.883]   - Field: 'expr'
[17:28:17.883]   - Field: 'uuid'
[17:28:17.883]   - Field: 'seed'
[17:28:17.883]   - Field: 'version'
[17:28:17.883]   - Field: 'result'
[17:28:17.883]   - Field: 'asynchronous'
[17:28:17.884]   - Field: 'calls'
[17:28:17.884]   - Field: 'globals'
[17:28:17.884]   - Field: 'stdout'
[17:28:17.884]   - Field: 'earlySignal'
[17:28:17.884]   - Field: 'lazy'
[17:28:17.884]   - Field: 'state'
[17:28:17.885] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.885] - Launch lazy future ...
[17:28:17.885] Packages needed by the future expression (n = 0): <none>
[17:28:17.885] Packages needed by future strategies (n = 0): <none>
[17:28:17.886] {
[17:28:17.886]     {
[17:28:17.886]         {
[17:28:17.886]             ...future.startTime <- base::Sys.time()
[17:28:17.886]             {
[17:28:17.886]                 {
[17:28:17.886]                   {
[17:28:17.886]                     base::local({
[17:28:17.886]                       has_future <- base::requireNamespace("future", 
[17:28:17.886]                         quietly = TRUE)
[17:28:17.886]                       if (has_future) {
[17:28:17.886]                         ns <- base::getNamespace("future")
[17:28:17.886]                         version <- ns[[".package"]][["version"]]
[17:28:17.886]                         if (is.null(version)) 
[17:28:17.886]                           version <- utils::packageVersion("future")
[17:28:17.886]                       }
[17:28:17.886]                       else {
[17:28:17.886]                         version <- NULL
[17:28:17.886]                       }
[17:28:17.886]                       if (!has_future || version < "1.8.0") {
[17:28:17.886]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.886]                           "", base::R.version$version.string), 
[17:28:17.886]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.886]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.886]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.886]                             "release", "version")], collapse = " "), 
[17:28:17.886]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.886]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.886]                           info)
[17:28:17.886]                         info <- base::paste(info, collapse = "; ")
[17:28:17.886]                         if (!has_future) {
[17:28:17.886]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.886]                             info)
[17:28:17.886]                         }
[17:28:17.886]                         else {
[17:28:17.886]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.886]                             info, version)
[17:28:17.886]                         }
[17:28:17.886]                         base::stop(msg)
[17:28:17.886]                       }
[17:28:17.886]                     })
[17:28:17.886]                   }
[17:28:17.886]                   ...future.strategy.old <- future::plan("list")
[17:28:17.886]                   options(future.plan = NULL)
[17:28:17.886]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.886]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.886]                 }
[17:28:17.886]                 ...future.workdir <- getwd()
[17:28:17.886]             }
[17:28:17.886]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.886]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.886]         }
[17:28:17.886]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.886]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.886]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.886]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.886]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.886]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.886]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.886]             base::names(...future.oldOptions))
[17:28:17.886]     }
[17:28:17.886]     if (FALSE) {
[17:28:17.886]     }
[17:28:17.886]     else {
[17:28:17.886]         if (TRUE) {
[17:28:17.886]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.886]                 open = "w")
[17:28:17.886]         }
[17:28:17.886]         else {
[17:28:17.886]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.886]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.886]         }
[17:28:17.886]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.886]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.886]             base::sink(type = "output", split = FALSE)
[17:28:17.886]             base::close(...future.stdout)
[17:28:17.886]         }, add = TRUE)
[17:28:17.886]     }
[17:28:17.886]     ...future.frame <- base::sys.nframe()
[17:28:17.886]     ...future.conditions <- base::list()
[17:28:17.886]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.886]     if (FALSE) {
[17:28:17.886]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.886]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.886]     }
[17:28:17.886]     ...future.result <- base::tryCatch({
[17:28:17.886]         base::withCallingHandlers({
[17:28:17.886]             ...future.value <- base::withVisible(base::local({
[17:28:17.886]                 sample(x, size = 1L)
[17:28:17.886]             }))
[17:28:17.886]             future::FutureResult(value = ...future.value$value, 
[17:28:17.886]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.886]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.886]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.886]                     ...future.globalenv.names))
[17:28:17.886]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.886]         }, condition = base::local({
[17:28:17.886]             c <- base::c
[17:28:17.886]             inherits <- base::inherits
[17:28:17.886]             invokeRestart <- base::invokeRestart
[17:28:17.886]             length <- base::length
[17:28:17.886]             list <- base::list
[17:28:17.886]             seq.int <- base::seq.int
[17:28:17.886]             signalCondition <- base::signalCondition
[17:28:17.886]             sys.calls <- base::sys.calls
[17:28:17.886]             `[[` <- base::`[[`
[17:28:17.886]             `+` <- base::`+`
[17:28:17.886]             `<<-` <- base::`<<-`
[17:28:17.886]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.886]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.886]                   3L)]
[17:28:17.886]             }
[17:28:17.886]             function(cond) {
[17:28:17.886]                 is_error <- inherits(cond, "error")
[17:28:17.886]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.886]                   NULL)
[17:28:17.886]                 if (is_error) {
[17:28:17.886]                   sessionInformation <- function() {
[17:28:17.886]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.886]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.886]                       search = base::search(), system = base::Sys.info())
[17:28:17.886]                   }
[17:28:17.886]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.886]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.886]                     cond$call), session = sessionInformation(), 
[17:28:17.886]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.886]                   signalCondition(cond)
[17:28:17.886]                 }
[17:28:17.886]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.886]                 "immediateCondition"))) {
[17:28:17.886]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.886]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.886]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.886]                   if (TRUE && !signal) {
[17:28:17.886]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.886]                     {
[17:28:17.886]                       inherits <- base::inherits
[17:28:17.886]                       invokeRestart <- base::invokeRestart
[17:28:17.886]                       is.null <- base::is.null
[17:28:17.886]                       muffled <- FALSE
[17:28:17.886]                       if (inherits(cond, "message")) {
[17:28:17.886]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.886]                         if (muffled) 
[17:28:17.886]                           invokeRestart("muffleMessage")
[17:28:17.886]                       }
[17:28:17.886]                       else if (inherits(cond, "warning")) {
[17:28:17.886]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.886]                         if (muffled) 
[17:28:17.886]                           invokeRestart("muffleWarning")
[17:28:17.886]                       }
[17:28:17.886]                       else if (inherits(cond, "condition")) {
[17:28:17.886]                         if (!is.null(pattern)) {
[17:28:17.886]                           computeRestarts <- base::computeRestarts
[17:28:17.886]                           grepl <- base::grepl
[17:28:17.886]                           restarts <- computeRestarts(cond)
[17:28:17.886]                           for (restart in restarts) {
[17:28:17.886]                             name <- restart$name
[17:28:17.886]                             if (is.null(name)) 
[17:28:17.886]                               next
[17:28:17.886]                             if (!grepl(pattern, name)) 
[17:28:17.886]                               next
[17:28:17.886]                             invokeRestart(restart)
[17:28:17.886]                             muffled <- TRUE
[17:28:17.886]                             break
[17:28:17.886]                           }
[17:28:17.886]                         }
[17:28:17.886]                       }
[17:28:17.886]                       invisible(muffled)
[17:28:17.886]                     }
[17:28:17.886]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.886]                   }
[17:28:17.886]                 }
[17:28:17.886]                 else {
[17:28:17.886]                   if (TRUE) {
[17:28:17.886]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.886]                     {
[17:28:17.886]                       inherits <- base::inherits
[17:28:17.886]                       invokeRestart <- base::invokeRestart
[17:28:17.886]                       is.null <- base::is.null
[17:28:17.886]                       muffled <- FALSE
[17:28:17.886]                       if (inherits(cond, "message")) {
[17:28:17.886]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.886]                         if (muffled) 
[17:28:17.886]                           invokeRestart("muffleMessage")
[17:28:17.886]                       }
[17:28:17.886]                       else if (inherits(cond, "warning")) {
[17:28:17.886]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.886]                         if (muffled) 
[17:28:17.886]                           invokeRestart("muffleWarning")
[17:28:17.886]                       }
[17:28:17.886]                       else if (inherits(cond, "condition")) {
[17:28:17.886]                         if (!is.null(pattern)) {
[17:28:17.886]                           computeRestarts <- base::computeRestarts
[17:28:17.886]                           grepl <- base::grepl
[17:28:17.886]                           restarts <- computeRestarts(cond)
[17:28:17.886]                           for (restart in restarts) {
[17:28:17.886]                             name <- restart$name
[17:28:17.886]                             if (is.null(name)) 
[17:28:17.886]                               next
[17:28:17.886]                             if (!grepl(pattern, name)) 
[17:28:17.886]                               next
[17:28:17.886]                             invokeRestart(restart)
[17:28:17.886]                             muffled <- TRUE
[17:28:17.886]                             break
[17:28:17.886]                           }
[17:28:17.886]                         }
[17:28:17.886]                       }
[17:28:17.886]                       invisible(muffled)
[17:28:17.886]                     }
[17:28:17.886]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.886]                   }
[17:28:17.886]                 }
[17:28:17.886]             }
[17:28:17.886]         }))
[17:28:17.886]     }, error = function(ex) {
[17:28:17.886]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.886]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.886]                 ...future.rng), started = ...future.startTime, 
[17:28:17.886]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.886]             version = "1.8"), class = "FutureResult")
[17:28:17.886]     }, finally = {
[17:28:17.886]         if (!identical(...future.workdir, getwd())) 
[17:28:17.886]             setwd(...future.workdir)
[17:28:17.886]         {
[17:28:17.886]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.886]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.886]             }
[17:28:17.886]             base::options(...future.oldOptions)
[17:28:17.886]             if (.Platform$OS.type == "windows") {
[17:28:17.886]                 old_names <- names(...future.oldEnvVars)
[17:28:17.886]                 envs <- base::Sys.getenv()
[17:28:17.886]                 names <- names(envs)
[17:28:17.886]                 common <- intersect(names, old_names)
[17:28:17.886]                 added <- setdiff(names, old_names)
[17:28:17.886]                 removed <- setdiff(old_names, names)
[17:28:17.886]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.886]                   envs[common]]
[17:28:17.886]                 NAMES <- toupper(changed)
[17:28:17.886]                 args <- list()
[17:28:17.886]                 for (kk in seq_along(NAMES)) {
[17:28:17.886]                   name <- changed[[kk]]
[17:28:17.886]                   NAME <- NAMES[[kk]]
[17:28:17.886]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.886]                     next
[17:28:17.886]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.886]                 }
[17:28:17.886]                 NAMES <- toupper(added)
[17:28:17.886]                 for (kk in seq_along(NAMES)) {
[17:28:17.886]                   name <- added[[kk]]
[17:28:17.886]                   NAME <- NAMES[[kk]]
[17:28:17.886]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.886]                     next
[17:28:17.886]                   args[[name]] <- ""
[17:28:17.886]                 }
[17:28:17.886]                 NAMES <- toupper(removed)
[17:28:17.886]                 for (kk in seq_along(NAMES)) {
[17:28:17.886]                   name <- removed[[kk]]
[17:28:17.886]                   NAME <- NAMES[[kk]]
[17:28:17.886]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.886]                     next
[17:28:17.886]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.886]                 }
[17:28:17.886]                 if (length(args) > 0) 
[17:28:17.886]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.886]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.886]             }
[17:28:17.886]             else {
[17:28:17.886]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.886]             }
[17:28:17.886]             {
[17:28:17.886]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.886]                   0L) {
[17:28:17.886]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.886]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.886]                   base::options(opts)
[17:28:17.886]                 }
[17:28:17.886]                 {
[17:28:17.886]                   {
[17:28:17.886]                     base::assign(".Random.seed", c(10407L, 817755046L, 
[17:28:17.886]                     -1167101805L, -1019604937L, -1013881922L, 
[17:28:17.886]                     1345551017L, 1896942424L), envir = base::globalenv(), 
[17:28:17.886]                       inherits = FALSE)
[17:28:17.886]                     NULL
[17:28:17.886]                   }
[17:28:17.886]                   options(future.plan = NULL)
[17:28:17.886]                   if (is.na(NA_character_)) 
[17:28:17.886]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.886]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.886]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.886]                     .init = FALSE)
[17:28:17.886]                 }
[17:28:17.886]             }
[17:28:17.886]         }
[17:28:17.886]     })
[17:28:17.886]     if (TRUE) {
[17:28:17.886]         base::sink(type = "output", split = FALSE)
[17:28:17.886]         if (TRUE) {
[17:28:17.886]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.886]         }
[17:28:17.886]         else {
[17:28:17.886]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.886]         }
[17:28:17.886]         base::close(...future.stdout)
[17:28:17.886]         ...future.stdout <- NULL
[17:28:17.886]     }
[17:28:17.886]     ...future.result$conditions <- ...future.conditions
[17:28:17.886]     ...future.result$finished <- base::Sys.time()
[17:28:17.886]     ...future.result
[17:28:17.886] }
[17:28:17.889] assign_globals() ...
[17:28:17.890] List of 1
[17:28:17.890]  $ x: int [1:4] 0 1 2 3
[17:28:17.890]  - attr(*, "where")=List of 1
[17:28:17.890]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.890]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.890]  - attr(*, "resolved")= logi FALSE
[17:28:17.890]  - attr(*, "total_size")= num 64
[17:28:17.890]  - attr(*, "already-done")= logi TRUE
[17:28:17.892] - copied 'x' to environment
[17:28:17.893] assign_globals() ... done
[17:28:17.893] plan(): Setting new future strategy stack:
[17:28:17.893] List of future strategies:
[17:28:17.893] 1. sequential:
[17:28:17.893]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.893]    - tweaked: FALSE
[17:28:17.893]    - call: NULL
[17:28:17.894] plan(): nbrOfWorkers() = 1
[17:28:17.895] plan(): Setting new future strategy stack:
[17:28:17.895] List of future strategies:
[17:28:17.895] 1. sequential:
[17:28:17.895]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.895]    - tweaked: FALSE
[17:28:17.895]    - call: plan(strategy)
[17:28:17.896] plan(): nbrOfWorkers() = 1
[17:28:17.896] SequentialFuture started (and completed)
[17:28:17.896] - Launch lazy future ... done
[17:28:17.896] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-741930'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x0000026671179538
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.897] getGlobalsAndPackages() ...
[17:28:17.897] Searching for globals...
[17:28:17.899] - globals found: [3] '{', 'sample', 'x'
[17:28:17.899] Searching for globals ... DONE
[17:28:17.899] Resolving globals: FALSE
[17:28:17.899] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.900] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.900] - globals: [1] 'x'
[17:28:17.900] 
[17:28:17.900] getGlobalsAndPackages() ... DONE
[17:28:17.901] run() for 'Future' ...
[17:28:17.901] - state: 'created'
[17:28:17.901] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.901] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.902] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.902]   - Field: 'label'
[17:28:17.902]   - Field: 'local'
[17:28:17.902]   - Field: 'owner'
[17:28:17.902]   - Field: 'envir'
[17:28:17.902]   - Field: 'packages'
[17:28:17.903]   - Field: 'gc'
[17:28:17.903]   - Field: 'conditions'
[17:28:17.903]   - Field: 'expr'
[17:28:17.903]   - Field: 'uuid'
[17:28:17.903]   - Field: 'seed'
[17:28:17.903]   - Field: 'version'
[17:28:17.904]   - Field: 'result'
[17:28:17.904]   - Field: 'asynchronous'
[17:28:17.904]   - Field: 'calls'
[17:28:17.904]   - Field: 'globals'
[17:28:17.904]   - Field: 'stdout'
[17:28:17.904]   - Field: 'earlySignal'
[17:28:17.905]   - Field: 'lazy'
[17:28:17.905]   - Field: 'state'
[17:28:17.905] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.905] - Launch lazy future ...
[17:28:17.905] Packages needed by the future expression (n = 0): <none>
[17:28:17.906] Packages needed by future strategies (n = 0): <none>
[17:28:17.906] {
[17:28:17.906]     {
[17:28:17.906]         {
[17:28:17.906]             ...future.startTime <- base::Sys.time()
[17:28:17.906]             {
[17:28:17.906]                 {
[17:28:17.906]                   {
[17:28:17.906]                     base::local({
[17:28:17.906]                       has_future <- base::requireNamespace("future", 
[17:28:17.906]                         quietly = TRUE)
[17:28:17.906]                       if (has_future) {
[17:28:17.906]                         ns <- base::getNamespace("future")
[17:28:17.906]                         version <- ns[[".package"]][["version"]]
[17:28:17.906]                         if (is.null(version)) 
[17:28:17.906]                           version <- utils::packageVersion("future")
[17:28:17.906]                       }
[17:28:17.906]                       else {
[17:28:17.906]                         version <- NULL
[17:28:17.906]                       }
[17:28:17.906]                       if (!has_future || version < "1.8.0") {
[17:28:17.906]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.906]                           "", base::R.version$version.string), 
[17:28:17.906]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.906]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.906]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.906]                             "release", "version")], collapse = " "), 
[17:28:17.906]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.906]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.906]                           info)
[17:28:17.906]                         info <- base::paste(info, collapse = "; ")
[17:28:17.906]                         if (!has_future) {
[17:28:17.906]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.906]                             info)
[17:28:17.906]                         }
[17:28:17.906]                         else {
[17:28:17.906]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.906]                             info, version)
[17:28:17.906]                         }
[17:28:17.906]                         base::stop(msg)
[17:28:17.906]                       }
[17:28:17.906]                     })
[17:28:17.906]                   }
[17:28:17.906]                   ...future.strategy.old <- future::plan("list")
[17:28:17.906]                   options(future.plan = NULL)
[17:28:17.906]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.906]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.906]                 }
[17:28:17.906]                 ...future.workdir <- getwd()
[17:28:17.906]             }
[17:28:17.906]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.906]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.906]         }
[17:28:17.906]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.906]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.906]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.906]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.906]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.906]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.906]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.906]             base::names(...future.oldOptions))
[17:28:17.906]     }
[17:28:17.906]     if (FALSE) {
[17:28:17.906]     }
[17:28:17.906]     else {
[17:28:17.906]         if (TRUE) {
[17:28:17.906]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.906]                 open = "w")
[17:28:17.906]         }
[17:28:17.906]         else {
[17:28:17.906]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.906]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.906]         }
[17:28:17.906]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.906]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.906]             base::sink(type = "output", split = FALSE)
[17:28:17.906]             base::close(...future.stdout)
[17:28:17.906]         }, add = TRUE)
[17:28:17.906]     }
[17:28:17.906]     ...future.frame <- base::sys.nframe()
[17:28:17.906]     ...future.conditions <- base::list()
[17:28:17.906]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.906]     if (FALSE) {
[17:28:17.906]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.906]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.906]     }
[17:28:17.906]     ...future.result <- base::tryCatch({
[17:28:17.906]         base::withCallingHandlers({
[17:28:17.906]             ...future.value <- base::withVisible(base::local({
[17:28:17.906]                 sample(x, size = 1L)
[17:28:17.906]             }))
[17:28:17.906]             future::FutureResult(value = ...future.value$value, 
[17:28:17.906]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.906]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.906]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.906]                     ...future.globalenv.names))
[17:28:17.906]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.906]         }, condition = base::local({
[17:28:17.906]             c <- base::c
[17:28:17.906]             inherits <- base::inherits
[17:28:17.906]             invokeRestart <- base::invokeRestart
[17:28:17.906]             length <- base::length
[17:28:17.906]             list <- base::list
[17:28:17.906]             seq.int <- base::seq.int
[17:28:17.906]             signalCondition <- base::signalCondition
[17:28:17.906]             sys.calls <- base::sys.calls
[17:28:17.906]             `[[` <- base::`[[`
[17:28:17.906]             `+` <- base::`+`
[17:28:17.906]             `<<-` <- base::`<<-`
[17:28:17.906]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.906]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.906]                   3L)]
[17:28:17.906]             }
[17:28:17.906]             function(cond) {
[17:28:17.906]                 is_error <- inherits(cond, "error")
[17:28:17.906]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.906]                   NULL)
[17:28:17.906]                 if (is_error) {
[17:28:17.906]                   sessionInformation <- function() {
[17:28:17.906]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.906]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.906]                       search = base::search(), system = base::Sys.info())
[17:28:17.906]                   }
[17:28:17.906]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.906]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.906]                     cond$call), session = sessionInformation(), 
[17:28:17.906]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.906]                   signalCondition(cond)
[17:28:17.906]                 }
[17:28:17.906]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.906]                 "immediateCondition"))) {
[17:28:17.906]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.906]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.906]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.906]                   if (TRUE && !signal) {
[17:28:17.906]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.906]                     {
[17:28:17.906]                       inherits <- base::inherits
[17:28:17.906]                       invokeRestart <- base::invokeRestart
[17:28:17.906]                       is.null <- base::is.null
[17:28:17.906]                       muffled <- FALSE
[17:28:17.906]                       if (inherits(cond, "message")) {
[17:28:17.906]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.906]                         if (muffled) 
[17:28:17.906]                           invokeRestart("muffleMessage")
[17:28:17.906]                       }
[17:28:17.906]                       else if (inherits(cond, "warning")) {
[17:28:17.906]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.906]                         if (muffled) 
[17:28:17.906]                           invokeRestart("muffleWarning")
[17:28:17.906]                       }
[17:28:17.906]                       else if (inherits(cond, "condition")) {
[17:28:17.906]                         if (!is.null(pattern)) {
[17:28:17.906]                           computeRestarts <- base::computeRestarts
[17:28:17.906]                           grepl <- base::grepl
[17:28:17.906]                           restarts <- computeRestarts(cond)
[17:28:17.906]                           for (restart in restarts) {
[17:28:17.906]                             name <- restart$name
[17:28:17.906]                             if (is.null(name)) 
[17:28:17.906]                               next
[17:28:17.906]                             if (!grepl(pattern, name)) 
[17:28:17.906]                               next
[17:28:17.906]                             invokeRestart(restart)
[17:28:17.906]                             muffled <- TRUE
[17:28:17.906]                             break
[17:28:17.906]                           }
[17:28:17.906]                         }
[17:28:17.906]                       }
[17:28:17.906]                       invisible(muffled)
[17:28:17.906]                     }
[17:28:17.906]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.906]                   }
[17:28:17.906]                 }
[17:28:17.906]                 else {
[17:28:17.906]                   if (TRUE) {
[17:28:17.906]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.906]                     {
[17:28:17.906]                       inherits <- base::inherits
[17:28:17.906]                       invokeRestart <- base::invokeRestart
[17:28:17.906]                       is.null <- base::is.null
[17:28:17.906]                       muffled <- FALSE
[17:28:17.906]                       if (inherits(cond, "message")) {
[17:28:17.906]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.906]                         if (muffled) 
[17:28:17.906]                           invokeRestart("muffleMessage")
[17:28:17.906]                       }
[17:28:17.906]                       else if (inherits(cond, "warning")) {
[17:28:17.906]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.906]                         if (muffled) 
[17:28:17.906]                           invokeRestart("muffleWarning")
[17:28:17.906]                       }
[17:28:17.906]                       else if (inherits(cond, "condition")) {
[17:28:17.906]                         if (!is.null(pattern)) {
[17:28:17.906]                           computeRestarts <- base::computeRestarts
[17:28:17.906]                           grepl <- base::grepl
[17:28:17.906]                           restarts <- computeRestarts(cond)
[17:28:17.906]                           for (restart in restarts) {
[17:28:17.906]                             name <- restart$name
[17:28:17.906]                             if (is.null(name)) 
[17:28:17.906]                               next
[17:28:17.906]                             if (!grepl(pattern, name)) 
[17:28:17.906]                               next
[17:28:17.906]                             invokeRestart(restart)
[17:28:17.906]                             muffled <- TRUE
[17:28:17.906]                             break
[17:28:17.906]                           }
[17:28:17.906]                         }
[17:28:17.906]                       }
[17:28:17.906]                       invisible(muffled)
[17:28:17.906]                     }
[17:28:17.906]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.906]                   }
[17:28:17.906]                 }
[17:28:17.906]             }
[17:28:17.906]         }))
[17:28:17.906]     }, error = function(ex) {
[17:28:17.906]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.906]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.906]                 ...future.rng), started = ...future.startTime, 
[17:28:17.906]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.906]             version = "1.8"), class = "FutureResult")
[17:28:17.906]     }, finally = {
[17:28:17.906]         if (!identical(...future.workdir, getwd())) 
[17:28:17.906]             setwd(...future.workdir)
[17:28:17.906]         {
[17:28:17.906]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.906]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.906]             }
[17:28:17.906]             base::options(...future.oldOptions)
[17:28:17.906]             if (.Platform$OS.type == "windows") {
[17:28:17.906]                 old_names <- names(...future.oldEnvVars)
[17:28:17.906]                 envs <- base::Sys.getenv()
[17:28:17.906]                 names <- names(envs)
[17:28:17.906]                 common <- intersect(names, old_names)
[17:28:17.906]                 added <- setdiff(names, old_names)
[17:28:17.906]                 removed <- setdiff(old_names, names)
[17:28:17.906]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.906]                   envs[common]]
[17:28:17.906]                 NAMES <- toupper(changed)
[17:28:17.906]                 args <- list()
[17:28:17.906]                 for (kk in seq_along(NAMES)) {
[17:28:17.906]                   name <- changed[[kk]]
[17:28:17.906]                   NAME <- NAMES[[kk]]
[17:28:17.906]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.906]                     next
[17:28:17.906]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.906]                 }
[17:28:17.906]                 NAMES <- toupper(added)
[17:28:17.906]                 for (kk in seq_along(NAMES)) {
[17:28:17.906]                   name <- added[[kk]]
[17:28:17.906]                   NAME <- NAMES[[kk]]
[17:28:17.906]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.906]                     next
[17:28:17.906]                   args[[name]] <- ""
[17:28:17.906]                 }
[17:28:17.906]                 NAMES <- toupper(removed)
[17:28:17.906]                 for (kk in seq_along(NAMES)) {
[17:28:17.906]                   name <- removed[[kk]]
[17:28:17.906]                   NAME <- NAMES[[kk]]
[17:28:17.906]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.906]                     next
[17:28:17.906]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.906]                 }
[17:28:17.906]                 if (length(args) > 0) 
[17:28:17.906]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.906]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.906]             }
[17:28:17.906]             else {
[17:28:17.906]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.906]             }
[17:28:17.906]             {
[17:28:17.906]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.906]                   0L) {
[17:28:17.906]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.906]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.906]                   base::options(opts)
[17:28:17.906]                 }
[17:28:17.906]                 {
[17:28:17.906]                   {
[17:28:17.906]                     base::assign(".Random.seed", c(10407L, -1019604937L, 
[17:28:17.906]                     -34713735L, -1667216435L, 1896942424L, 740037062L, 
[17:28:17.906]                     -783328168L), envir = base::globalenv(), 
[17:28:17.906]                       inherits = FALSE)
[17:28:17.906]                     NULL
[17:28:17.906]                   }
[17:28:17.906]                   options(future.plan = NULL)
[17:28:17.906]                   if (is.na(NA_character_)) 
[17:28:17.906]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.906]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.906]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.906]                     .init = FALSE)
[17:28:17.906]                 }
[17:28:17.906]             }
[17:28:17.906]         }
[17:28:17.906]     })
[17:28:17.906]     if (TRUE) {
[17:28:17.906]         base::sink(type = "output", split = FALSE)
[17:28:17.906]         if (TRUE) {
[17:28:17.906]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.906]         }
[17:28:17.906]         else {
[17:28:17.906]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.906]         }
[17:28:17.906]         base::close(...future.stdout)
[17:28:17.906]         ...future.stdout <- NULL
[17:28:17.906]     }
[17:28:17.906]     ...future.result$conditions <- ...future.conditions
[17:28:17.906]     ...future.result$finished <- base::Sys.time()
[17:28:17.906]     ...future.result
[17:28:17.906] }
[17:28:17.910] assign_globals() ...
[17:28:17.910] List of 1
[17:28:17.910]  $ x: int [1:4] 0 1 2 3
[17:28:17.910]  - attr(*, "where")=List of 1
[17:28:17.910]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.910]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.910]  - attr(*, "resolved")= logi FALSE
[17:28:17.910]  - attr(*, "total_size")= num 64
[17:28:17.910]  - attr(*, "already-done")= logi TRUE
[17:28:17.914] - copied 'x' to environment
[17:28:17.914] assign_globals() ... done
[17:28:17.914] plan(): Setting new future strategy stack:
[17:28:17.914] List of future strategies:
[17:28:17.914] 1. sequential:
[17:28:17.914]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.914]    - tweaked: FALSE
[17:28:17.914]    - call: NULL
[17:28:17.915] plan(): nbrOfWorkers() = 1
[17:28:17.916] plan(): Setting new future strategy stack:
[17:28:17.916] List of future strategies:
[17:28:17.916] 1. sequential:
[17:28:17.916]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.916]    - tweaked: FALSE
[17:28:17.916]    - call: plan(strategy)
[17:28:17.917] plan(): nbrOfWorkers() = 1
[17:28:17.917] SequentialFuture started (and completed)
[17:28:17.917] - Launch lazy future ... done
[17:28:17.918] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-183121'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x0000026671179538
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.919] getGlobalsAndPackages() ...
[17:28:17.919] Searching for globals...
[17:28:17.920] - globals found: [3] '{', 'sample', 'x'
[17:28:17.920] Searching for globals ... DONE
[17:28:17.920] Resolving globals: FALSE
[17:28:17.921] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.921] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.921] - globals: [1] 'x'
[17:28:17.921] 
[17:28:17.922] getGlobalsAndPackages() ... DONE
[17:28:17.922] run() for 'Future' ...
[17:28:17.922] - state: 'created'
[17:28:17.922] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.923] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.923] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.923]   - Field: 'label'
[17:28:17.923]   - Field: 'local'
[17:28:17.923]   - Field: 'owner'
[17:28:17.924]   - Field: 'envir'
[17:28:17.924]   - Field: 'packages'
[17:28:17.924]   - Field: 'gc'
[17:28:17.924]   - Field: 'conditions'
[17:28:17.924]   - Field: 'expr'
[17:28:17.924]   - Field: 'uuid'
[17:28:17.925]   - Field: 'seed'
[17:28:17.925]   - Field: 'version'
[17:28:17.925]   - Field: 'result'
[17:28:17.925]   - Field: 'asynchronous'
[17:28:17.925]   - Field: 'calls'
[17:28:17.925]   - Field: 'globals'
[17:28:17.926]   - Field: 'stdout'
[17:28:17.926]   - Field: 'earlySignal'
[17:28:17.926]   - Field: 'lazy'
[17:28:17.926]   - Field: 'state'
[17:28:17.926] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.927] - Launch lazy future ...
[17:28:17.927] Packages needed by the future expression (n = 0): <none>
[17:28:17.927] Packages needed by future strategies (n = 0): <none>
[17:28:17.927] {
[17:28:17.927]     {
[17:28:17.927]         {
[17:28:17.927]             ...future.startTime <- base::Sys.time()
[17:28:17.927]             {
[17:28:17.927]                 {
[17:28:17.927]                   {
[17:28:17.927]                     base::local({
[17:28:17.927]                       has_future <- base::requireNamespace("future", 
[17:28:17.927]                         quietly = TRUE)
[17:28:17.927]                       if (has_future) {
[17:28:17.927]                         ns <- base::getNamespace("future")
[17:28:17.927]                         version <- ns[[".package"]][["version"]]
[17:28:17.927]                         if (is.null(version)) 
[17:28:17.927]                           version <- utils::packageVersion("future")
[17:28:17.927]                       }
[17:28:17.927]                       else {
[17:28:17.927]                         version <- NULL
[17:28:17.927]                       }
[17:28:17.927]                       if (!has_future || version < "1.8.0") {
[17:28:17.927]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.927]                           "", base::R.version$version.string), 
[17:28:17.927]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:17.927]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.927]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.927]                             "release", "version")], collapse = " "), 
[17:28:17.927]                           hostname = base::Sys.info()[["nodename"]])
[17:28:17.927]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.927]                           info)
[17:28:17.927]                         info <- base::paste(info, collapse = "; ")
[17:28:17.927]                         if (!has_future) {
[17:28:17.927]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.927]                             info)
[17:28:17.927]                         }
[17:28:17.927]                         else {
[17:28:17.927]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.927]                             info, version)
[17:28:17.927]                         }
[17:28:17.927]                         base::stop(msg)
[17:28:17.927]                       }
[17:28:17.927]                     })
[17:28:17.927]                   }
[17:28:17.927]                   ...future.strategy.old <- future::plan("list")
[17:28:17.927]                   options(future.plan = NULL)
[17:28:17.927]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.927]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:17.927]                 }
[17:28:17.927]                 ...future.workdir <- getwd()
[17:28:17.927]             }
[17:28:17.927]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.927]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.927]         }
[17:28:17.927]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.927]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.927]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.927]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.927]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.927]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.927]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.927]             base::names(...future.oldOptions))
[17:28:17.927]     }
[17:28:17.927]     if (FALSE) {
[17:28:17.927]     }
[17:28:17.927]     else {
[17:28:17.927]         if (TRUE) {
[17:28:17.927]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.927]                 open = "w")
[17:28:17.927]         }
[17:28:17.927]         else {
[17:28:17.927]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.927]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.927]         }
[17:28:17.927]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.927]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.927]             base::sink(type = "output", split = FALSE)
[17:28:17.927]             base::close(...future.stdout)
[17:28:17.927]         }, add = TRUE)
[17:28:17.927]     }
[17:28:17.927]     ...future.frame <- base::sys.nframe()
[17:28:17.927]     ...future.conditions <- base::list()
[17:28:17.927]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.927]     if (FALSE) {
[17:28:17.927]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.927]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.927]     }
[17:28:17.927]     ...future.result <- base::tryCatch({
[17:28:17.927]         base::withCallingHandlers({
[17:28:17.927]             ...future.value <- base::withVisible(base::local({
[17:28:17.927]                 sample(x, size = 1L)
[17:28:17.927]             }))
[17:28:17.927]             future::FutureResult(value = ...future.value$value, 
[17:28:17.927]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.927]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.927]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.927]                     ...future.globalenv.names))
[17:28:17.927]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.927]         }, condition = base::local({
[17:28:17.927]             c <- base::c
[17:28:17.927]             inherits <- base::inherits
[17:28:17.927]             invokeRestart <- base::invokeRestart
[17:28:17.927]             length <- base::length
[17:28:17.927]             list <- base::list
[17:28:17.927]             seq.int <- base::seq.int
[17:28:17.927]             signalCondition <- base::signalCondition
[17:28:17.927]             sys.calls <- base::sys.calls
[17:28:17.927]             `[[` <- base::`[[`
[17:28:17.927]             `+` <- base::`+`
[17:28:17.927]             `<<-` <- base::`<<-`
[17:28:17.927]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.927]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.927]                   3L)]
[17:28:17.927]             }
[17:28:17.927]             function(cond) {
[17:28:17.927]                 is_error <- inherits(cond, "error")
[17:28:17.927]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.927]                   NULL)
[17:28:17.927]                 if (is_error) {
[17:28:17.927]                   sessionInformation <- function() {
[17:28:17.927]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.927]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.927]                       search = base::search(), system = base::Sys.info())
[17:28:17.927]                   }
[17:28:17.927]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.927]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.927]                     cond$call), session = sessionInformation(), 
[17:28:17.927]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.927]                   signalCondition(cond)
[17:28:17.927]                 }
[17:28:17.927]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.927]                 "immediateCondition"))) {
[17:28:17.927]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.927]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.927]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.927]                   if (TRUE && !signal) {
[17:28:17.927]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.927]                     {
[17:28:17.927]                       inherits <- base::inherits
[17:28:17.927]                       invokeRestart <- base::invokeRestart
[17:28:17.927]                       is.null <- base::is.null
[17:28:17.927]                       muffled <- FALSE
[17:28:17.927]                       if (inherits(cond, "message")) {
[17:28:17.927]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.927]                         if (muffled) 
[17:28:17.927]                           invokeRestart("muffleMessage")
[17:28:17.927]                       }
[17:28:17.927]                       else if (inherits(cond, "warning")) {
[17:28:17.927]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.927]                         if (muffled) 
[17:28:17.927]                           invokeRestart("muffleWarning")
[17:28:17.927]                       }
[17:28:17.927]                       else if (inherits(cond, "condition")) {
[17:28:17.927]                         if (!is.null(pattern)) {
[17:28:17.927]                           computeRestarts <- base::computeRestarts
[17:28:17.927]                           grepl <- base::grepl
[17:28:17.927]                           restarts <- computeRestarts(cond)
[17:28:17.927]                           for (restart in restarts) {
[17:28:17.927]                             name <- restart$name
[17:28:17.927]                             if (is.null(name)) 
[17:28:17.927]                               next
[17:28:17.927]                             if (!grepl(pattern, name)) 
[17:28:17.927]                               next
[17:28:17.927]                             invokeRestart(restart)
[17:28:17.927]                             muffled <- TRUE
[17:28:17.927]                             break
[17:28:17.927]                           }
[17:28:17.927]                         }
[17:28:17.927]                       }
[17:28:17.927]                       invisible(muffled)
[17:28:17.927]                     }
[17:28:17.927]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.927]                   }
[17:28:17.927]                 }
[17:28:17.927]                 else {
[17:28:17.927]                   if (TRUE) {
[17:28:17.927]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.927]                     {
[17:28:17.927]                       inherits <- base::inherits
[17:28:17.927]                       invokeRestart <- base::invokeRestart
[17:28:17.927]                       is.null <- base::is.null
[17:28:17.927]                       muffled <- FALSE
[17:28:17.927]                       if (inherits(cond, "message")) {
[17:28:17.927]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.927]                         if (muffled) 
[17:28:17.927]                           invokeRestart("muffleMessage")
[17:28:17.927]                       }
[17:28:17.927]                       else if (inherits(cond, "warning")) {
[17:28:17.927]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.927]                         if (muffled) 
[17:28:17.927]                           invokeRestart("muffleWarning")
[17:28:17.927]                       }
[17:28:17.927]                       else if (inherits(cond, "condition")) {
[17:28:17.927]                         if (!is.null(pattern)) {
[17:28:17.927]                           computeRestarts <- base::computeRestarts
[17:28:17.927]                           grepl <- base::grepl
[17:28:17.927]                           restarts <- computeRestarts(cond)
[17:28:17.927]                           for (restart in restarts) {
[17:28:17.927]                             name <- restart$name
[17:28:17.927]                             if (is.null(name)) 
[17:28:17.927]                               next
[17:28:17.927]                             if (!grepl(pattern, name)) 
[17:28:17.927]                               next
[17:28:17.927]                             invokeRestart(restart)
[17:28:17.927]                             muffled <- TRUE
[17:28:17.927]                             break
[17:28:17.927]                           }
[17:28:17.927]                         }
[17:28:17.927]                       }
[17:28:17.927]                       invisible(muffled)
[17:28:17.927]                     }
[17:28:17.927]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.927]                   }
[17:28:17.927]                 }
[17:28:17.927]             }
[17:28:17.927]         }))
[17:28:17.927]     }, error = function(ex) {
[17:28:17.927]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.927]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.927]                 ...future.rng), started = ...future.startTime, 
[17:28:17.927]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.927]             version = "1.8"), class = "FutureResult")
[17:28:17.927]     }, finally = {
[17:28:17.927]         if (!identical(...future.workdir, getwd())) 
[17:28:17.927]             setwd(...future.workdir)
[17:28:17.927]         {
[17:28:17.927]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.927]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.927]             }
[17:28:17.927]             base::options(...future.oldOptions)
[17:28:17.927]             if (.Platform$OS.type == "windows") {
[17:28:17.927]                 old_names <- names(...future.oldEnvVars)
[17:28:17.927]                 envs <- base::Sys.getenv()
[17:28:17.927]                 names <- names(envs)
[17:28:17.927]                 common <- intersect(names, old_names)
[17:28:17.927]                 added <- setdiff(names, old_names)
[17:28:17.927]                 removed <- setdiff(old_names, names)
[17:28:17.927]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.927]                   envs[common]]
[17:28:17.927]                 NAMES <- toupper(changed)
[17:28:17.927]                 args <- list()
[17:28:17.927]                 for (kk in seq_along(NAMES)) {
[17:28:17.927]                   name <- changed[[kk]]
[17:28:17.927]                   NAME <- NAMES[[kk]]
[17:28:17.927]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.927]                     next
[17:28:17.927]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.927]                 }
[17:28:17.927]                 NAMES <- toupper(added)
[17:28:17.927]                 for (kk in seq_along(NAMES)) {
[17:28:17.927]                   name <- added[[kk]]
[17:28:17.927]                   NAME <- NAMES[[kk]]
[17:28:17.927]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.927]                     next
[17:28:17.927]                   args[[name]] <- ""
[17:28:17.927]                 }
[17:28:17.927]                 NAMES <- toupper(removed)
[17:28:17.927]                 for (kk in seq_along(NAMES)) {
[17:28:17.927]                   name <- removed[[kk]]
[17:28:17.927]                   NAME <- NAMES[[kk]]
[17:28:17.927]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.927]                     next
[17:28:17.927]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.927]                 }
[17:28:17.927]                 if (length(args) > 0) 
[17:28:17.927]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.927]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.927]             }
[17:28:17.927]             else {
[17:28:17.927]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.927]             }
[17:28:17.927]             {
[17:28:17.927]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.927]                   0L) {
[17:28:17.927]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.927]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.927]                   base::options(opts)
[17:28:17.927]                 }
[17:28:17.927]                 {
[17:28:17.927]                   {
[17:28:17.927]                     base::assign(".Random.seed", c(10407L, -1667216435L, 
[17:28:17.927]                     -1252731658L, 1120344904L, -783328168L, -1236028416L, 
[17:28:17.927]                     -1054736142L), envir = base::globalenv(), 
[17:28:17.927]                       inherits = FALSE)
[17:28:17.927]                     NULL
[17:28:17.927]                   }
[17:28:17.927]                   options(future.plan = NULL)
[17:28:17.927]                   if (is.na(NA_character_)) 
[17:28:17.927]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.927]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.927]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.927]                     .init = FALSE)
[17:28:17.927]                 }
[17:28:17.927]             }
[17:28:17.927]         }
[17:28:17.927]     })
[17:28:17.927]     if (TRUE) {
[17:28:17.927]         base::sink(type = "output", split = FALSE)
[17:28:17.927]         if (TRUE) {
[17:28:17.927]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.927]         }
[17:28:17.927]         else {
[17:28:17.927]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.927]         }
[17:28:17.927]         base::close(...future.stdout)
[17:28:17.927]         ...future.stdout <- NULL
[17:28:17.927]     }
[17:28:17.927]     ...future.result$conditions <- ...future.conditions
[17:28:17.927]     ...future.result$finished <- base::Sys.time()
[17:28:17.927]     ...future.result
[17:28:17.927] }
[17:28:17.931] assign_globals() ...
[17:28:17.931] List of 1
[17:28:17.931]  $ x: int [1:4] 0 1 2 3
[17:28:17.931]  - attr(*, "where")=List of 1
[17:28:17.931]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.931]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.931]  - attr(*, "resolved")= logi FALSE
[17:28:17.931]  - attr(*, "total_size")= num 64
[17:28:17.931]  - attr(*, "already-done")= logi TRUE
[17:28:17.934] - copied 'x' to environment
[17:28:17.934] assign_globals() ... done
[17:28:17.935] plan(): Setting new future strategy stack:
[17:28:17.935] List of future strategies:
[17:28:17.935] 1. sequential:
[17:28:17.935]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.935]    - tweaked: FALSE
[17:28:17.935]    - call: NULL
[17:28:17.935] plan(): nbrOfWorkers() = 1
[17:28:17.937] plan(): Setting new future strategy stack:
[17:28:17.937] List of future strategies:
[17:28:17.937] 1. sequential:
[17:28:17.937]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.937]    - tweaked: FALSE
[17:28:17.937]    - call: plan(strategy)
[17:28:17.938] plan(): nbrOfWorkers() = 1
[17:28:17.938] SequentialFuture started (and completed)
[17:28:17.938] - Launch lazy future ... done
[17:28:17.938] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-98726'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x0000026671179538
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.939] resolve() on list ...
[17:28:17.939]  recursive: 0
[17:28:17.939]  length: 4
[17:28:17.940] 
[17:28:17.940] resolved() for 'SequentialFuture' ...
[17:28:17.940] - state: 'finished'
[17:28:17.940] - run: TRUE
[17:28:17.940] - result: 'FutureResult'
[17:28:17.940] resolved() for 'SequentialFuture' ... done
[17:28:17.941] Future #1
[17:28:17.941] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:28:17.941] - nx: 4
[17:28:17.941] - relay: TRUE
[17:28:17.941] - stdout: TRUE
[17:28:17.941] - signal: TRUE
[17:28:17.942] - resignal: FALSE
[17:28:17.942] - force: TRUE
[17:28:17.942] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.942] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:17.942]  - until=1
[17:28:17.942]  - relaying element #1
[17:28:17.943] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.943] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.943] signalConditionsASAP(SequentialFuture, pos=1) ... done
[17:28:17.943]  length: 3 (resolved future 1)
[17:28:17.943] resolved() for 'SequentialFuture' ...
[17:28:17.944] - state: 'finished'
[17:28:17.944] - run: TRUE
[17:28:17.945] - result: 'FutureResult'
[17:28:17.945] resolved() for 'SequentialFuture' ... done
[17:28:17.945] Future #2
[17:28:17.945] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:28:17.945] - nx: 4
[17:28:17.946] - relay: TRUE
[17:28:17.946] - stdout: TRUE
[17:28:17.946] - signal: TRUE
[17:28:17.946] - resignal: FALSE
[17:28:17.946] - force: TRUE
[17:28:17.946] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.947] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:17.947]  - until=2
[17:28:17.947]  - relaying element #2
[17:28:17.947] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.947] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.947] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:28:17.948]  length: 2 (resolved future 2)
[17:28:17.948] resolved() for 'SequentialFuture' ...
[17:28:17.948] - state: 'finished'
[17:28:17.948] - run: TRUE
[17:28:17.948] - result: 'FutureResult'
[17:28:17.949] resolved() for 'SequentialFuture' ... done
[17:28:17.949] Future #3
[17:28:17.949] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:28:17.949] - nx: 4
[17:28:17.949] - relay: TRUE
[17:28:17.949] - stdout: TRUE
[17:28:17.950] - signal: TRUE
[17:28:17.950] - resignal: FALSE
[17:28:17.950] - force: TRUE
[17:28:17.950] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.950] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:17.950]  - until=3
[17:28:17.950]  - relaying element #3
[17:28:17.951] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.951] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.951] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:28:17.951]  length: 1 (resolved future 3)
[17:28:17.951] resolved() for 'SequentialFuture' ...
[17:28:17.952] - state: 'finished'
[17:28:17.952] - run: TRUE
[17:28:17.952] - result: 'FutureResult'
[17:28:17.952] resolved() for 'SequentialFuture' ... done
[17:28:17.952] Future #4
[17:28:17.952] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:28:17.953] - nx: 4
[17:28:17.953] - relay: TRUE
[17:28:17.953] - stdout: TRUE
[17:28:17.953] - signal: TRUE
[17:28:17.953] - resignal: FALSE
[17:28:17.953] - force: TRUE
[17:28:17.954] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.954] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:17.954]  - until=4
[17:28:17.954]  - relaying element #4
[17:28:17.954] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.954] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.955] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:28:17.955]  length: 0 (resolved future 4)
[17:28:17.955] Relaying remaining futures
[17:28:17.955] signalConditionsASAP(NULL, pos=0) ...
[17:28:17.955] - nx: 4
[17:28:17.955] - relay: TRUE
[17:28:17.955] - stdout: TRUE
[17:28:17.956] - signal: TRUE
[17:28:17.956] - resignal: FALSE
[17:28:17.956] - force: TRUE
[17:28:17.956] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.956] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:28:17.956] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.957] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:17.957] signalConditionsASAP(NULL, pos=0) ... done
[17:28:17.957] resolve() on list ... DONE
[[1]]
[1] 3

[[2]]
[1] 2

[[3]]
[1] 1

[[4]]
[1] 3

[17:28:17.959] getGlobalsAndPackages() ...
[17:28:17.959] Searching for globals...
[17:28:17.960] - globals found: [3] '{', 'sample', 'x'
[17:28:17.960] Searching for globals ... DONE
[17:28:17.960] Resolving globals: FALSE
[17:28:17.961] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.961] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.961] - globals: [1] 'x'
[17:28:17.962] 
[17:28:17.962] getGlobalsAndPackages() ... DONE
[17:28:17.962] run() for 'Future' ...
[17:28:17.962] - state: 'created'
[17:28:17.963] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.963] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.963] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.963]   - Field: 'label'
[17:28:17.963]   - Field: 'local'
[17:28:17.964]   - Field: 'owner'
[17:28:17.964]   - Field: 'envir'
[17:28:17.964]   - Field: 'packages'
[17:28:17.964]   - Field: 'gc'
[17:28:17.964]   - Field: 'conditions'
[17:28:17.964]   - Field: 'expr'
[17:28:17.965]   - Field: 'uuid'
[17:28:17.965]   - Field: 'seed'
[17:28:17.965]   - Field: 'version'
[17:28:17.965]   - Field: 'result'
[17:28:17.965]   - Field: 'asynchronous'
[17:28:17.965]   - Field: 'calls'
[17:28:17.966]   - Field: 'globals'
[17:28:17.966]   - Field: 'stdout'
[17:28:17.966]   - Field: 'earlySignal'
[17:28:17.966]   - Field: 'lazy'
[17:28:17.966]   - Field: 'state'
[17:28:17.967] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.967] - Launch lazy future ...
[17:28:17.967] Packages needed by the future expression (n = 0): <none>
[17:28:17.967] Packages needed by future strategies (n = 0): <none>
[17:28:17.968] {
[17:28:17.968]     {
[17:28:17.968]         {
[17:28:17.968]             ...future.startTime <- base::Sys.time()
[17:28:17.968]             {
[17:28:17.968]                 {
[17:28:17.968]                   {
[17:28:17.968]                     {
[17:28:17.968]                       base::local({
[17:28:17.968]                         has_future <- base::requireNamespace("future", 
[17:28:17.968]                           quietly = TRUE)
[17:28:17.968]                         if (has_future) {
[17:28:17.968]                           ns <- base::getNamespace("future")
[17:28:17.968]                           version <- ns[[".package"]][["version"]]
[17:28:17.968]                           if (is.null(version)) 
[17:28:17.968]                             version <- utils::packageVersion("future")
[17:28:17.968]                         }
[17:28:17.968]                         else {
[17:28:17.968]                           version <- NULL
[17:28:17.968]                         }
[17:28:17.968]                         if (!has_future || version < "1.8.0") {
[17:28:17.968]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.968]                             "", base::R.version$version.string), 
[17:28:17.968]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:17.968]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.968]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.968]                               "release", "version")], collapse = " "), 
[17:28:17.968]                             hostname = base::Sys.info()[["nodename"]])
[17:28:17.968]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.968]                             info)
[17:28:17.968]                           info <- base::paste(info, collapse = "; ")
[17:28:17.968]                           if (!has_future) {
[17:28:17.968]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.968]                               info)
[17:28:17.968]                           }
[17:28:17.968]                           else {
[17:28:17.968]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.968]                               info, version)
[17:28:17.968]                           }
[17:28:17.968]                           base::stop(msg)
[17:28:17.968]                         }
[17:28:17.968]                       })
[17:28:17.968]                     }
[17:28:17.968]                     ...future.strategy.old <- future::plan("list")
[17:28:17.968]                     options(future.plan = NULL)
[17:28:17.968]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.968]                     future::plan("default", .cleanup = FALSE, 
[17:28:17.968]                       .init = FALSE)
[17:28:17.968]                   }
[17:28:17.968]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:28:17.968]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:28:17.968]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:28:17.968]                 }
[17:28:17.968]                 ...future.workdir <- getwd()
[17:28:17.968]             }
[17:28:17.968]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.968]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.968]         }
[17:28:17.968]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.968]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.968]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.968]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.968]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.968]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.968]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.968]             base::names(...future.oldOptions))
[17:28:17.968]     }
[17:28:17.968]     if (FALSE) {
[17:28:17.968]     }
[17:28:17.968]     else {
[17:28:17.968]         if (TRUE) {
[17:28:17.968]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.968]                 open = "w")
[17:28:17.968]         }
[17:28:17.968]         else {
[17:28:17.968]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.968]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.968]         }
[17:28:17.968]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.968]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.968]             base::sink(type = "output", split = FALSE)
[17:28:17.968]             base::close(...future.stdout)
[17:28:17.968]         }, add = TRUE)
[17:28:17.968]     }
[17:28:17.968]     ...future.frame <- base::sys.nframe()
[17:28:17.968]     ...future.conditions <- base::list()
[17:28:17.968]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.968]     if (FALSE) {
[17:28:17.968]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.968]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.968]     }
[17:28:17.968]     ...future.result <- base::tryCatch({
[17:28:17.968]         base::withCallingHandlers({
[17:28:17.968]             ...future.value <- base::withVisible(base::local({
[17:28:17.968]                 sample(x, size = 1L)
[17:28:17.968]             }))
[17:28:17.968]             future::FutureResult(value = ...future.value$value, 
[17:28:17.968]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.968]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.968]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.968]                     ...future.globalenv.names))
[17:28:17.968]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.968]         }, condition = base::local({
[17:28:17.968]             c <- base::c
[17:28:17.968]             inherits <- base::inherits
[17:28:17.968]             invokeRestart <- base::invokeRestart
[17:28:17.968]             length <- base::length
[17:28:17.968]             list <- base::list
[17:28:17.968]             seq.int <- base::seq.int
[17:28:17.968]             signalCondition <- base::signalCondition
[17:28:17.968]             sys.calls <- base::sys.calls
[17:28:17.968]             `[[` <- base::`[[`
[17:28:17.968]             `+` <- base::`+`
[17:28:17.968]             `<<-` <- base::`<<-`
[17:28:17.968]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.968]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.968]                   3L)]
[17:28:17.968]             }
[17:28:17.968]             function(cond) {
[17:28:17.968]                 is_error <- inherits(cond, "error")
[17:28:17.968]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.968]                   NULL)
[17:28:17.968]                 if (is_error) {
[17:28:17.968]                   sessionInformation <- function() {
[17:28:17.968]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.968]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.968]                       search = base::search(), system = base::Sys.info())
[17:28:17.968]                   }
[17:28:17.968]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.968]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.968]                     cond$call), session = sessionInformation(), 
[17:28:17.968]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.968]                   signalCondition(cond)
[17:28:17.968]                 }
[17:28:17.968]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.968]                 "immediateCondition"))) {
[17:28:17.968]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.968]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.968]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.968]                   if (TRUE && !signal) {
[17:28:17.968]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.968]                     {
[17:28:17.968]                       inherits <- base::inherits
[17:28:17.968]                       invokeRestart <- base::invokeRestart
[17:28:17.968]                       is.null <- base::is.null
[17:28:17.968]                       muffled <- FALSE
[17:28:17.968]                       if (inherits(cond, "message")) {
[17:28:17.968]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.968]                         if (muffled) 
[17:28:17.968]                           invokeRestart("muffleMessage")
[17:28:17.968]                       }
[17:28:17.968]                       else if (inherits(cond, "warning")) {
[17:28:17.968]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.968]                         if (muffled) 
[17:28:17.968]                           invokeRestart("muffleWarning")
[17:28:17.968]                       }
[17:28:17.968]                       else if (inherits(cond, "condition")) {
[17:28:17.968]                         if (!is.null(pattern)) {
[17:28:17.968]                           computeRestarts <- base::computeRestarts
[17:28:17.968]                           grepl <- base::grepl
[17:28:17.968]                           restarts <- computeRestarts(cond)
[17:28:17.968]                           for (restart in restarts) {
[17:28:17.968]                             name <- restart$name
[17:28:17.968]                             if (is.null(name)) 
[17:28:17.968]                               next
[17:28:17.968]                             if (!grepl(pattern, name)) 
[17:28:17.968]                               next
[17:28:17.968]                             invokeRestart(restart)
[17:28:17.968]                             muffled <- TRUE
[17:28:17.968]                             break
[17:28:17.968]                           }
[17:28:17.968]                         }
[17:28:17.968]                       }
[17:28:17.968]                       invisible(muffled)
[17:28:17.968]                     }
[17:28:17.968]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.968]                   }
[17:28:17.968]                 }
[17:28:17.968]                 else {
[17:28:17.968]                   if (TRUE) {
[17:28:17.968]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.968]                     {
[17:28:17.968]                       inherits <- base::inherits
[17:28:17.968]                       invokeRestart <- base::invokeRestart
[17:28:17.968]                       is.null <- base::is.null
[17:28:17.968]                       muffled <- FALSE
[17:28:17.968]                       if (inherits(cond, "message")) {
[17:28:17.968]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.968]                         if (muffled) 
[17:28:17.968]                           invokeRestart("muffleMessage")
[17:28:17.968]                       }
[17:28:17.968]                       else if (inherits(cond, "warning")) {
[17:28:17.968]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.968]                         if (muffled) 
[17:28:17.968]                           invokeRestart("muffleWarning")
[17:28:17.968]                       }
[17:28:17.968]                       else if (inherits(cond, "condition")) {
[17:28:17.968]                         if (!is.null(pattern)) {
[17:28:17.968]                           computeRestarts <- base::computeRestarts
[17:28:17.968]                           grepl <- base::grepl
[17:28:17.968]                           restarts <- computeRestarts(cond)
[17:28:17.968]                           for (restart in restarts) {
[17:28:17.968]                             name <- restart$name
[17:28:17.968]                             if (is.null(name)) 
[17:28:17.968]                               next
[17:28:17.968]                             if (!grepl(pattern, name)) 
[17:28:17.968]                               next
[17:28:17.968]                             invokeRestart(restart)
[17:28:17.968]                             muffled <- TRUE
[17:28:17.968]                             break
[17:28:17.968]                           }
[17:28:17.968]                         }
[17:28:17.968]                       }
[17:28:17.968]                       invisible(muffled)
[17:28:17.968]                     }
[17:28:17.968]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.968]                   }
[17:28:17.968]                 }
[17:28:17.968]             }
[17:28:17.968]         }))
[17:28:17.968]     }, error = function(ex) {
[17:28:17.968]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.968]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.968]                 ...future.rng), started = ...future.startTime, 
[17:28:17.968]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.968]             version = "1.8"), class = "FutureResult")
[17:28:17.968]     }, finally = {
[17:28:17.968]         if (!identical(...future.workdir, getwd())) 
[17:28:17.968]             setwd(...future.workdir)
[17:28:17.968]         {
[17:28:17.968]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.968]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.968]             }
[17:28:17.968]             base::options(...future.oldOptions)
[17:28:17.968]             if (.Platform$OS.type == "windows") {
[17:28:17.968]                 old_names <- names(...future.oldEnvVars)
[17:28:17.968]                 envs <- base::Sys.getenv()
[17:28:17.968]                 names <- names(envs)
[17:28:17.968]                 common <- intersect(names, old_names)
[17:28:17.968]                 added <- setdiff(names, old_names)
[17:28:17.968]                 removed <- setdiff(old_names, names)
[17:28:17.968]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.968]                   envs[common]]
[17:28:17.968]                 NAMES <- toupper(changed)
[17:28:17.968]                 args <- list()
[17:28:17.968]                 for (kk in seq_along(NAMES)) {
[17:28:17.968]                   name <- changed[[kk]]
[17:28:17.968]                   NAME <- NAMES[[kk]]
[17:28:17.968]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.968]                     next
[17:28:17.968]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.968]                 }
[17:28:17.968]                 NAMES <- toupper(added)
[17:28:17.968]                 for (kk in seq_along(NAMES)) {
[17:28:17.968]                   name <- added[[kk]]
[17:28:17.968]                   NAME <- NAMES[[kk]]
[17:28:17.968]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.968]                     next
[17:28:17.968]                   args[[name]] <- ""
[17:28:17.968]                 }
[17:28:17.968]                 NAMES <- toupper(removed)
[17:28:17.968]                 for (kk in seq_along(NAMES)) {
[17:28:17.968]                   name <- removed[[kk]]
[17:28:17.968]                   NAME <- NAMES[[kk]]
[17:28:17.968]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.968]                     next
[17:28:17.968]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.968]                 }
[17:28:17.968]                 if (length(args) > 0) 
[17:28:17.968]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.968]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.968]             }
[17:28:17.968]             else {
[17:28:17.968]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.968]             }
[17:28:17.968]             {
[17:28:17.968]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.968]                   0L) {
[17:28:17.968]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.968]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.968]                   base::options(opts)
[17:28:17.968]                 }
[17:28:17.968]                 {
[17:28:17.968]                   {
[17:28:17.968]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:17.968]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:17.968]                     -1344458670L), envir = base::globalenv(), 
[17:28:17.968]                       inherits = FALSE)
[17:28:17.968]                     NULL
[17:28:17.968]                   }
[17:28:17.968]                   options(future.plan = NULL)
[17:28:17.968]                   if (is.na(NA_character_)) 
[17:28:17.968]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.968]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.968]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.968]                     .init = FALSE)
[17:28:17.968]                 }
[17:28:17.968]             }
[17:28:17.968]         }
[17:28:17.968]     })
[17:28:17.968]     if (TRUE) {
[17:28:17.968]         base::sink(type = "output", split = FALSE)
[17:28:17.968]         if (TRUE) {
[17:28:17.968]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.968]         }
[17:28:17.968]         else {
[17:28:17.968]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.968]         }
[17:28:17.968]         base::close(...future.stdout)
[17:28:17.968]         ...future.stdout <- NULL
[17:28:17.968]     }
[17:28:17.968]     ...future.result$conditions <- ...future.conditions
[17:28:17.968]     ...future.result$finished <- base::Sys.time()
[17:28:17.968]     ...future.result
[17:28:17.968] }
[17:28:17.971] assign_globals() ...
[17:28:17.972] List of 1
[17:28:17.972]  $ x: int [1:4] 0 1 2 3
[17:28:17.972]  - attr(*, "where")=List of 1
[17:28:17.972]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.972]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.972]  - attr(*, "resolved")= logi FALSE
[17:28:17.972]  - attr(*, "total_size")= num 64
[17:28:17.972]  - attr(*, "already-done")= logi TRUE
[17:28:17.974] - copied 'x' to environment
[17:28:17.975] assign_globals() ... done
[17:28:17.975] plan(): Setting new future strategy stack:
[17:28:17.975] List of future strategies:
[17:28:17.975] 1. sequential:
[17:28:17.975]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.975]    - tweaked: FALSE
[17:28:17.975]    - call: NULL
[17:28:17.976] plan(): nbrOfWorkers() = 1
[17:28:17.978] plan(): Setting new future strategy stack:
[17:28:17.978] List of future strategies:
[17:28:17.978] 1. sequential:
[17:28:17.978]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.978]    - tweaked: FALSE
[17:28:17.978]    - call: plan(strategy)
[17:28:17.979] plan(): nbrOfWorkers() = 1
[17:28:17.979] SequentialFuture started (and completed)
[17:28:17.979] - Launch lazy future ... done
[17:28:17.979] run() for 'SequentialFuture' ... done
[17:28:17.980] getGlobalsAndPackages() ...
[17:28:17.980] Searching for globals...
[17:28:17.981] - globals found: [3] '{', 'sample', 'x'
[17:28:17.981] Searching for globals ... DONE
[17:28:17.981] Resolving globals: FALSE
[17:28:17.982] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:17.982] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:17.982] - globals: [1] 'x'
[17:28:17.983] 
[17:28:17.983] getGlobalsAndPackages() ... DONE
[17:28:17.983] run() for 'Future' ...
[17:28:17.983] - state: 'created'
[17:28:17.983] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:17.984] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:17.984] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:17.984]   - Field: 'label'
[17:28:17.984]   - Field: 'local'
[17:28:17.985]   - Field: 'owner'
[17:28:17.985]   - Field: 'envir'
[17:28:17.985]   - Field: 'packages'
[17:28:17.985]   - Field: 'gc'
[17:28:17.985]   - Field: 'conditions'
[17:28:17.985]   - Field: 'expr'
[17:28:17.986]   - Field: 'uuid'
[17:28:17.986]   - Field: 'seed'
[17:28:17.986]   - Field: 'version'
[17:28:17.986]   - Field: 'result'
[17:28:17.986]   - Field: 'asynchronous'
[17:28:17.986]   - Field: 'calls'
[17:28:17.987]   - Field: 'globals'
[17:28:17.987]   - Field: 'stdout'
[17:28:17.987]   - Field: 'earlySignal'
[17:28:17.987]   - Field: 'lazy'
[17:28:17.987]   - Field: 'state'
[17:28:17.987] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:17.988] - Launch lazy future ...
[17:28:17.988] Packages needed by the future expression (n = 0): <none>
[17:28:17.988] Packages needed by future strategies (n = 0): <none>
[17:28:17.989] {
[17:28:17.989]     {
[17:28:17.989]         {
[17:28:17.989]             ...future.startTime <- base::Sys.time()
[17:28:17.989]             {
[17:28:17.989]                 {
[17:28:17.989]                   {
[17:28:17.989]                     {
[17:28:17.989]                       base::local({
[17:28:17.989]                         has_future <- base::requireNamespace("future", 
[17:28:17.989]                           quietly = TRUE)
[17:28:17.989]                         if (has_future) {
[17:28:17.989]                           ns <- base::getNamespace("future")
[17:28:17.989]                           version <- ns[[".package"]][["version"]]
[17:28:17.989]                           if (is.null(version)) 
[17:28:17.989]                             version <- utils::packageVersion("future")
[17:28:17.989]                         }
[17:28:17.989]                         else {
[17:28:17.989]                           version <- NULL
[17:28:17.989]                         }
[17:28:17.989]                         if (!has_future || version < "1.8.0") {
[17:28:17.989]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:17.989]                             "", base::R.version$version.string), 
[17:28:17.989]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:17.989]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:17.989]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:17.989]                               "release", "version")], collapse = " "), 
[17:28:17.989]                             hostname = base::Sys.info()[["nodename"]])
[17:28:17.989]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:17.989]                             info)
[17:28:17.989]                           info <- base::paste(info, collapse = "; ")
[17:28:17.989]                           if (!has_future) {
[17:28:17.989]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:17.989]                               info)
[17:28:17.989]                           }
[17:28:17.989]                           else {
[17:28:17.989]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:17.989]                               info, version)
[17:28:17.989]                           }
[17:28:17.989]                           base::stop(msg)
[17:28:17.989]                         }
[17:28:17.989]                       })
[17:28:17.989]                     }
[17:28:17.989]                     ...future.strategy.old <- future::plan("list")
[17:28:17.989]                     options(future.plan = NULL)
[17:28:17.989]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.989]                     future::plan("default", .cleanup = FALSE, 
[17:28:17.989]                       .init = FALSE)
[17:28:17.989]                   }
[17:28:17.989]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:28:17.989]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:28:17.989]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:28:17.989]                 }
[17:28:17.989]                 ...future.workdir <- getwd()
[17:28:17.989]             }
[17:28:17.989]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:17.989]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:17.989]         }
[17:28:17.989]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:17.989]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:17.989]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:17.989]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:17.989]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:17.989]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:17.989]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:17.989]             base::names(...future.oldOptions))
[17:28:17.989]     }
[17:28:17.989]     if (FALSE) {
[17:28:17.989]     }
[17:28:17.989]     else {
[17:28:17.989]         if (TRUE) {
[17:28:17.989]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:17.989]                 open = "w")
[17:28:17.989]         }
[17:28:17.989]         else {
[17:28:17.989]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:17.989]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:17.989]         }
[17:28:17.989]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:17.989]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:17.989]             base::sink(type = "output", split = FALSE)
[17:28:17.989]             base::close(...future.stdout)
[17:28:17.989]         }, add = TRUE)
[17:28:17.989]     }
[17:28:17.989]     ...future.frame <- base::sys.nframe()
[17:28:17.989]     ...future.conditions <- base::list()
[17:28:17.989]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:17.989]     if (FALSE) {
[17:28:17.989]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:17.989]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:17.989]     }
[17:28:17.989]     ...future.result <- base::tryCatch({
[17:28:17.989]         base::withCallingHandlers({
[17:28:17.989]             ...future.value <- base::withVisible(base::local({
[17:28:17.989]                 sample(x, size = 1L)
[17:28:17.989]             }))
[17:28:17.989]             future::FutureResult(value = ...future.value$value, 
[17:28:17.989]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.989]                   ...future.rng), globalenv = if (FALSE) 
[17:28:17.989]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:17.989]                     ...future.globalenv.names))
[17:28:17.989]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:17.989]         }, condition = base::local({
[17:28:17.989]             c <- base::c
[17:28:17.989]             inherits <- base::inherits
[17:28:17.989]             invokeRestart <- base::invokeRestart
[17:28:17.989]             length <- base::length
[17:28:17.989]             list <- base::list
[17:28:17.989]             seq.int <- base::seq.int
[17:28:17.989]             signalCondition <- base::signalCondition
[17:28:17.989]             sys.calls <- base::sys.calls
[17:28:17.989]             `[[` <- base::`[[`
[17:28:17.989]             `+` <- base::`+`
[17:28:17.989]             `<<-` <- base::`<<-`
[17:28:17.989]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:17.989]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:17.989]                   3L)]
[17:28:17.989]             }
[17:28:17.989]             function(cond) {
[17:28:17.989]                 is_error <- inherits(cond, "error")
[17:28:17.989]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:17.989]                   NULL)
[17:28:17.989]                 if (is_error) {
[17:28:17.989]                   sessionInformation <- function() {
[17:28:17.989]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:17.989]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:17.989]                       search = base::search(), system = base::Sys.info())
[17:28:17.989]                   }
[17:28:17.989]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.989]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:17.989]                     cond$call), session = sessionInformation(), 
[17:28:17.989]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:17.989]                   signalCondition(cond)
[17:28:17.989]                 }
[17:28:17.989]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:17.989]                 "immediateCondition"))) {
[17:28:17.989]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:17.989]                   ...future.conditions[[length(...future.conditions) + 
[17:28:17.989]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:17.989]                   if (TRUE && !signal) {
[17:28:17.989]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.989]                     {
[17:28:17.989]                       inherits <- base::inherits
[17:28:17.989]                       invokeRestart <- base::invokeRestart
[17:28:17.989]                       is.null <- base::is.null
[17:28:17.989]                       muffled <- FALSE
[17:28:17.989]                       if (inherits(cond, "message")) {
[17:28:17.989]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.989]                         if (muffled) 
[17:28:17.989]                           invokeRestart("muffleMessage")
[17:28:17.989]                       }
[17:28:17.989]                       else if (inherits(cond, "warning")) {
[17:28:17.989]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.989]                         if (muffled) 
[17:28:17.989]                           invokeRestart("muffleWarning")
[17:28:17.989]                       }
[17:28:17.989]                       else if (inherits(cond, "condition")) {
[17:28:17.989]                         if (!is.null(pattern)) {
[17:28:17.989]                           computeRestarts <- base::computeRestarts
[17:28:17.989]                           grepl <- base::grepl
[17:28:17.989]                           restarts <- computeRestarts(cond)
[17:28:17.989]                           for (restart in restarts) {
[17:28:17.989]                             name <- restart$name
[17:28:17.989]                             if (is.null(name)) 
[17:28:17.989]                               next
[17:28:17.989]                             if (!grepl(pattern, name)) 
[17:28:17.989]                               next
[17:28:17.989]                             invokeRestart(restart)
[17:28:17.989]                             muffled <- TRUE
[17:28:17.989]                             break
[17:28:17.989]                           }
[17:28:17.989]                         }
[17:28:17.989]                       }
[17:28:17.989]                       invisible(muffled)
[17:28:17.989]                     }
[17:28:17.989]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.989]                   }
[17:28:17.989]                 }
[17:28:17.989]                 else {
[17:28:17.989]                   if (TRUE) {
[17:28:17.989]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:17.989]                     {
[17:28:17.989]                       inherits <- base::inherits
[17:28:17.989]                       invokeRestart <- base::invokeRestart
[17:28:17.989]                       is.null <- base::is.null
[17:28:17.989]                       muffled <- FALSE
[17:28:17.989]                       if (inherits(cond, "message")) {
[17:28:17.989]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:17.989]                         if (muffled) 
[17:28:17.989]                           invokeRestart("muffleMessage")
[17:28:17.989]                       }
[17:28:17.989]                       else if (inherits(cond, "warning")) {
[17:28:17.989]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:17.989]                         if (muffled) 
[17:28:17.989]                           invokeRestart("muffleWarning")
[17:28:17.989]                       }
[17:28:17.989]                       else if (inherits(cond, "condition")) {
[17:28:17.989]                         if (!is.null(pattern)) {
[17:28:17.989]                           computeRestarts <- base::computeRestarts
[17:28:17.989]                           grepl <- base::grepl
[17:28:17.989]                           restarts <- computeRestarts(cond)
[17:28:17.989]                           for (restart in restarts) {
[17:28:17.989]                             name <- restart$name
[17:28:17.989]                             if (is.null(name)) 
[17:28:17.989]                               next
[17:28:17.989]                             if (!grepl(pattern, name)) 
[17:28:17.989]                               next
[17:28:17.989]                             invokeRestart(restart)
[17:28:17.989]                             muffled <- TRUE
[17:28:17.989]                             break
[17:28:17.989]                           }
[17:28:17.989]                         }
[17:28:17.989]                       }
[17:28:17.989]                       invisible(muffled)
[17:28:17.989]                     }
[17:28:17.989]                     muffleCondition(cond, pattern = "^muffle")
[17:28:17.989]                   }
[17:28:17.989]                 }
[17:28:17.989]             }
[17:28:17.989]         }))
[17:28:17.989]     }, error = function(ex) {
[17:28:17.989]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:17.989]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:17.989]                 ...future.rng), started = ...future.startTime, 
[17:28:17.989]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:17.989]             version = "1.8"), class = "FutureResult")
[17:28:17.989]     }, finally = {
[17:28:17.989]         if (!identical(...future.workdir, getwd())) 
[17:28:17.989]             setwd(...future.workdir)
[17:28:17.989]         {
[17:28:17.989]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:17.989]                 ...future.oldOptions$nwarnings <- NULL
[17:28:17.989]             }
[17:28:17.989]             base::options(...future.oldOptions)
[17:28:17.989]             if (.Platform$OS.type == "windows") {
[17:28:17.989]                 old_names <- names(...future.oldEnvVars)
[17:28:17.989]                 envs <- base::Sys.getenv()
[17:28:17.989]                 names <- names(envs)
[17:28:17.989]                 common <- intersect(names, old_names)
[17:28:17.989]                 added <- setdiff(names, old_names)
[17:28:17.989]                 removed <- setdiff(old_names, names)
[17:28:17.989]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:17.989]                   envs[common]]
[17:28:17.989]                 NAMES <- toupper(changed)
[17:28:17.989]                 args <- list()
[17:28:17.989]                 for (kk in seq_along(NAMES)) {
[17:28:17.989]                   name <- changed[[kk]]
[17:28:17.989]                   NAME <- NAMES[[kk]]
[17:28:17.989]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.989]                     next
[17:28:17.989]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.989]                 }
[17:28:17.989]                 NAMES <- toupper(added)
[17:28:17.989]                 for (kk in seq_along(NAMES)) {
[17:28:17.989]                   name <- added[[kk]]
[17:28:17.989]                   NAME <- NAMES[[kk]]
[17:28:17.989]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.989]                     next
[17:28:17.989]                   args[[name]] <- ""
[17:28:17.989]                 }
[17:28:17.989]                 NAMES <- toupper(removed)
[17:28:17.989]                 for (kk in seq_along(NAMES)) {
[17:28:17.989]                   name <- removed[[kk]]
[17:28:17.989]                   NAME <- NAMES[[kk]]
[17:28:17.989]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:17.989]                     next
[17:28:17.989]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:17.989]                 }
[17:28:17.989]                 if (length(args) > 0) 
[17:28:17.989]                   base::do.call(base::Sys.setenv, args = args)
[17:28:17.989]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:17.989]             }
[17:28:17.989]             else {
[17:28:17.989]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:17.989]             }
[17:28:17.989]             {
[17:28:17.989]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:17.989]                   0L) {
[17:28:17.989]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:17.989]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:17.989]                   base::options(opts)
[17:28:17.989]                 }
[17:28:17.989]                 {
[17:28:17.989]                   {
[17:28:17.989]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:17.989]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:17.989]                     -1344458670L), envir = base::globalenv(), 
[17:28:17.989]                       inherits = FALSE)
[17:28:17.989]                     NULL
[17:28:17.989]                   }
[17:28:17.989]                   options(future.plan = NULL)
[17:28:17.989]                   if (is.na(NA_character_)) 
[17:28:17.989]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:17.989]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:17.989]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:17.989]                     .init = FALSE)
[17:28:17.989]                 }
[17:28:17.989]             }
[17:28:17.989]         }
[17:28:17.989]     })
[17:28:17.989]     if (TRUE) {
[17:28:17.989]         base::sink(type = "output", split = FALSE)
[17:28:17.989]         if (TRUE) {
[17:28:17.989]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:17.989]         }
[17:28:17.989]         else {
[17:28:17.989]             ...future.result["stdout"] <- base::list(NULL)
[17:28:17.989]         }
[17:28:17.989]         base::close(...future.stdout)
[17:28:17.989]         ...future.stdout <- NULL
[17:28:17.989]     }
[17:28:17.989]     ...future.result$conditions <- ...future.conditions
[17:28:17.989]     ...future.result$finished <- base::Sys.time()
[17:28:17.989]     ...future.result
[17:28:17.989] }
[17:28:17.992] assign_globals() ...
[17:28:17.992] List of 1
[17:28:17.992]  $ x: int [1:4] 0 1 2 3
[17:28:17.992]  - attr(*, "where")=List of 1
[17:28:17.992]   ..$ x:<environment: R_EmptyEnv> 
[17:28:17.992]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:17.992]  - attr(*, "resolved")= logi FALSE
[17:28:17.992]  - attr(*, "total_size")= num 64
[17:28:17.992]  - attr(*, "already-done")= logi TRUE
[17:28:17.995] - copied 'x' to environment
[17:28:17.995] assign_globals() ... done
[17:28:17.996] plan(): Setting new future strategy stack:
[17:28:17.996] List of future strategies:
[17:28:17.996] 1. sequential:
[17:28:17.996]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.996]    - tweaked: FALSE
[17:28:17.996]    - call: NULL
[17:28:17.997] plan(): nbrOfWorkers() = 1
[17:28:17.998] plan(): Setting new future strategy stack:
[17:28:17.998] List of future strategies:
[17:28:17.998] 1. sequential:
[17:28:17.998]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:17.998]    - tweaked: FALSE
[17:28:17.998]    - call: plan(strategy)
[17:28:17.999] plan(): nbrOfWorkers() = 1
[17:28:17.999] SequentialFuture started (and completed)
[17:28:17.999] - Launch lazy future ... done
[17:28:17.999] run() for 'SequentialFuture' ... done
[17:28:18.000] getGlobalsAndPackages() ...
[17:28:18.000] Searching for globals...
[17:28:18.001] - globals found: [3] '{', 'sample', 'x'
[17:28:18.001] Searching for globals ... DONE
[17:28:18.001] Resolving globals: FALSE
[17:28:18.002] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.002] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.003] - globals: [1] 'x'
[17:28:18.003] 
[17:28:18.003] getGlobalsAndPackages() ... DONE
[17:28:18.003] run() for 'Future' ...
[17:28:18.003] - state: 'created'
[17:28:18.004] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.004] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.004] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.004]   - Field: 'label'
[17:28:18.004]   - Field: 'local'
[17:28:18.005]   - Field: 'owner'
[17:28:18.005]   - Field: 'envir'
[17:28:18.005]   - Field: 'packages'
[17:28:18.005]   - Field: 'gc'
[17:28:18.005]   - Field: 'conditions'
[17:28:18.006]   - Field: 'expr'
[17:28:18.006]   - Field: 'uuid'
[17:28:18.006]   - Field: 'seed'
[17:28:18.006]   - Field: 'version'
[17:28:18.006]   - Field: 'result'
[17:28:18.006]   - Field: 'asynchronous'
[17:28:18.007]   - Field: 'calls'
[17:28:18.008]   - Field: 'globals'
[17:28:18.008]   - Field: 'stdout'
[17:28:18.008]   - Field: 'earlySignal'
[17:28:18.008]   - Field: 'lazy'
[17:28:18.008]   - Field: 'state'
[17:28:18.008] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.009] - Launch lazy future ...
[17:28:18.009] Packages needed by the future expression (n = 0): <none>
[17:28:18.009] Packages needed by future strategies (n = 0): <none>
[17:28:18.010] {
[17:28:18.010]     {
[17:28:18.010]         {
[17:28:18.010]             ...future.startTime <- base::Sys.time()
[17:28:18.010]             {
[17:28:18.010]                 {
[17:28:18.010]                   {
[17:28:18.010]                     {
[17:28:18.010]                       base::local({
[17:28:18.010]                         has_future <- base::requireNamespace("future", 
[17:28:18.010]                           quietly = TRUE)
[17:28:18.010]                         if (has_future) {
[17:28:18.010]                           ns <- base::getNamespace("future")
[17:28:18.010]                           version <- ns[[".package"]][["version"]]
[17:28:18.010]                           if (is.null(version)) 
[17:28:18.010]                             version <- utils::packageVersion("future")
[17:28:18.010]                         }
[17:28:18.010]                         else {
[17:28:18.010]                           version <- NULL
[17:28:18.010]                         }
[17:28:18.010]                         if (!has_future || version < "1.8.0") {
[17:28:18.010]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.010]                             "", base::R.version$version.string), 
[17:28:18.010]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:18.010]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.010]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.010]                               "release", "version")], collapse = " "), 
[17:28:18.010]                             hostname = base::Sys.info()[["nodename"]])
[17:28:18.010]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.010]                             info)
[17:28:18.010]                           info <- base::paste(info, collapse = "; ")
[17:28:18.010]                           if (!has_future) {
[17:28:18.010]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.010]                               info)
[17:28:18.010]                           }
[17:28:18.010]                           else {
[17:28:18.010]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.010]                               info, version)
[17:28:18.010]                           }
[17:28:18.010]                           base::stop(msg)
[17:28:18.010]                         }
[17:28:18.010]                       })
[17:28:18.010]                     }
[17:28:18.010]                     ...future.strategy.old <- future::plan("list")
[17:28:18.010]                     options(future.plan = NULL)
[17:28:18.010]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.010]                     future::plan("default", .cleanup = FALSE, 
[17:28:18.010]                       .init = FALSE)
[17:28:18.010]                   }
[17:28:18.010]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:28:18.010]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:28:18.010]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:28:18.010]                 }
[17:28:18.010]                 ...future.workdir <- getwd()
[17:28:18.010]             }
[17:28:18.010]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.010]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.010]         }
[17:28:18.010]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.010]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.010]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.010]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.010]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.010]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.010]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.010]             base::names(...future.oldOptions))
[17:28:18.010]     }
[17:28:18.010]     if (FALSE) {
[17:28:18.010]     }
[17:28:18.010]     else {
[17:28:18.010]         if (TRUE) {
[17:28:18.010]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.010]                 open = "w")
[17:28:18.010]         }
[17:28:18.010]         else {
[17:28:18.010]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.010]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.010]         }
[17:28:18.010]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.010]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.010]             base::sink(type = "output", split = FALSE)
[17:28:18.010]             base::close(...future.stdout)
[17:28:18.010]         }, add = TRUE)
[17:28:18.010]     }
[17:28:18.010]     ...future.frame <- base::sys.nframe()
[17:28:18.010]     ...future.conditions <- base::list()
[17:28:18.010]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.010]     if (FALSE) {
[17:28:18.010]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.010]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.010]     }
[17:28:18.010]     ...future.result <- base::tryCatch({
[17:28:18.010]         base::withCallingHandlers({
[17:28:18.010]             ...future.value <- base::withVisible(base::local({
[17:28:18.010]                 sample(x, size = 1L)
[17:28:18.010]             }))
[17:28:18.010]             future::FutureResult(value = ...future.value$value, 
[17:28:18.010]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.010]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.010]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.010]                     ...future.globalenv.names))
[17:28:18.010]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.010]         }, condition = base::local({
[17:28:18.010]             c <- base::c
[17:28:18.010]             inherits <- base::inherits
[17:28:18.010]             invokeRestart <- base::invokeRestart
[17:28:18.010]             length <- base::length
[17:28:18.010]             list <- base::list
[17:28:18.010]             seq.int <- base::seq.int
[17:28:18.010]             signalCondition <- base::signalCondition
[17:28:18.010]             sys.calls <- base::sys.calls
[17:28:18.010]             `[[` <- base::`[[`
[17:28:18.010]             `+` <- base::`+`
[17:28:18.010]             `<<-` <- base::`<<-`
[17:28:18.010]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.010]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.010]                   3L)]
[17:28:18.010]             }
[17:28:18.010]             function(cond) {
[17:28:18.010]                 is_error <- inherits(cond, "error")
[17:28:18.010]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.010]                   NULL)
[17:28:18.010]                 if (is_error) {
[17:28:18.010]                   sessionInformation <- function() {
[17:28:18.010]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.010]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.010]                       search = base::search(), system = base::Sys.info())
[17:28:18.010]                   }
[17:28:18.010]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.010]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.010]                     cond$call), session = sessionInformation(), 
[17:28:18.010]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.010]                   signalCondition(cond)
[17:28:18.010]                 }
[17:28:18.010]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.010]                 "immediateCondition"))) {
[17:28:18.010]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.010]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.010]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.010]                   if (TRUE && !signal) {
[17:28:18.010]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.010]                     {
[17:28:18.010]                       inherits <- base::inherits
[17:28:18.010]                       invokeRestart <- base::invokeRestart
[17:28:18.010]                       is.null <- base::is.null
[17:28:18.010]                       muffled <- FALSE
[17:28:18.010]                       if (inherits(cond, "message")) {
[17:28:18.010]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.010]                         if (muffled) 
[17:28:18.010]                           invokeRestart("muffleMessage")
[17:28:18.010]                       }
[17:28:18.010]                       else if (inherits(cond, "warning")) {
[17:28:18.010]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.010]                         if (muffled) 
[17:28:18.010]                           invokeRestart("muffleWarning")
[17:28:18.010]                       }
[17:28:18.010]                       else if (inherits(cond, "condition")) {
[17:28:18.010]                         if (!is.null(pattern)) {
[17:28:18.010]                           computeRestarts <- base::computeRestarts
[17:28:18.010]                           grepl <- base::grepl
[17:28:18.010]                           restarts <- computeRestarts(cond)
[17:28:18.010]                           for (restart in restarts) {
[17:28:18.010]                             name <- restart$name
[17:28:18.010]                             if (is.null(name)) 
[17:28:18.010]                               next
[17:28:18.010]                             if (!grepl(pattern, name)) 
[17:28:18.010]                               next
[17:28:18.010]                             invokeRestart(restart)
[17:28:18.010]                             muffled <- TRUE
[17:28:18.010]                             break
[17:28:18.010]                           }
[17:28:18.010]                         }
[17:28:18.010]                       }
[17:28:18.010]                       invisible(muffled)
[17:28:18.010]                     }
[17:28:18.010]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.010]                   }
[17:28:18.010]                 }
[17:28:18.010]                 else {
[17:28:18.010]                   if (TRUE) {
[17:28:18.010]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.010]                     {
[17:28:18.010]                       inherits <- base::inherits
[17:28:18.010]                       invokeRestart <- base::invokeRestart
[17:28:18.010]                       is.null <- base::is.null
[17:28:18.010]                       muffled <- FALSE
[17:28:18.010]                       if (inherits(cond, "message")) {
[17:28:18.010]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.010]                         if (muffled) 
[17:28:18.010]                           invokeRestart("muffleMessage")
[17:28:18.010]                       }
[17:28:18.010]                       else if (inherits(cond, "warning")) {
[17:28:18.010]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.010]                         if (muffled) 
[17:28:18.010]                           invokeRestart("muffleWarning")
[17:28:18.010]                       }
[17:28:18.010]                       else if (inherits(cond, "condition")) {
[17:28:18.010]                         if (!is.null(pattern)) {
[17:28:18.010]                           computeRestarts <- base::computeRestarts
[17:28:18.010]                           grepl <- base::grepl
[17:28:18.010]                           restarts <- computeRestarts(cond)
[17:28:18.010]                           for (restart in restarts) {
[17:28:18.010]                             name <- restart$name
[17:28:18.010]                             if (is.null(name)) 
[17:28:18.010]                               next
[17:28:18.010]                             if (!grepl(pattern, name)) 
[17:28:18.010]                               next
[17:28:18.010]                             invokeRestart(restart)
[17:28:18.010]                             muffled <- TRUE
[17:28:18.010]                             break
[17:28:18.010]                           }
[17:28:18.010]                         }
[17:28:18.010]                       }
[17:28:18.010]                       invisible(muffled)
[17:28:18.010]                     }
[17:28:18.010]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.010]                   }
[17:28:18.010]                 }
[17:28:18.010]             }
[17:28:18.010]         }))
[17:28:18.010]     }, error = function(ex) {
[17:28:18.010]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.010]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.010]                 ...future.rng), started = ...future.startTime, 
[17:28:18.010]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.010]             version = "1.8"), class = "FutureResult")
[17:28:18.010]     }, finally = {
[17:28:18.010]         if (!identical(...future.workdir, getwd())) 
[17:28:18.010]             setwd(...future.workdir)
[17:28:18.010]         {
[17:28:18.010]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.010]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.010]             }
[17:28:18.010]             base::options(...future.oldOptions)
[17:28:18.010]             if (.Platform$OS.type == "windows") {
[17:28:18.010]                 old_names <- names(...future.oldEnvVars)
[17:28:18.010]                 envs <- base::Sys.getenv()
[17:28:18.010]                 names <- names(envs)
[17:28:18.010]                 common <- intersect(names, old_names)
[17:28:18.010]                 added <- setdiff(names, old_names)
[17:28:18.010]                 removed <- setdiff(old_names, names)
[17:28:18.010]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.010]                   envs[common]]
[17:28:18.010]                 NAMES <- toupper(changed)
[17:28:18.010]                 args <- list()
[17:28:18.010]                 for (kk in seq_along(NAMES)) {
[17:28:18.010]                   name <- changed[[kk]]
[17:28:18.010]                   NAME <- NAMES[[kk]]
[17:28:18.010]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.010]                     next
[17:28:18.010]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.010]                 }
[17:28:18.010]                 NAMES <- toupper(added)
[17:28:18.010]                 for (kk in seq_along(NAMES)) {
[17:28:18.010]                   name <- added[[kk]]
[17:28:18.010]                   NAME <- NAMES[[kk]]
[17:28:18.010]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.010]                     next
[17:28:18.010]                   args[[name]] <- ""
[17:28:18.010]                 }
[17:28:18.010]                 NAMES <- toupper(removed)
[17:28:18.010]                 for (kk in seq_along(NAMES)) {
[17:28:18.010]                   name <- removed[[kk]]
[17:28:18.010]                   NAME <- NAMES[[kk]]
[17:28:18.010]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.010]                     next
[17:28:18.010]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.010]                 }
[17:28:18.010]                 if (length(args) > 0) 
[17:28:18.010]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.010]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.010]             }
[17:28:18.010]             else {
[17:28:18.010]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.010]             }
[17:28:18.010]             {
[17:28:18.010]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.010]                   0L) {
[17:28:18.010]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.010]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.010]                   base::options(opts)
[17:28:18.010]                 }
[17:28:18.010]                 {
[17:28:18.010]                   {
[17:28:18.010]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:18.010]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:18.010]                     -1344458670L), envir = base::globalenv(), 
[17:28:18.010]                       inherits = FALSE)
[17:28:18.010]                     NULL
[17:28:18.010]                   }
[17:28:18.010]                   options(future.plan = NULL)
[17:28:18.010]                   if (is.na(NA_character_)) 
[17:28:18.010]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.010]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.010]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.010]                     .init = FALSE)
[17:28:18.010]                 }
[17:28:18.010]             }
[17:28:18.010]         }
[17:28:18.010]     })
[17:28:18.010]     if (TRUE) {
[17:28:18.010]         base::sink(type = "output", split = FALSE)
[17:28:18.010]         if (TRUE) {
[17:28:18.010]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.010]         }
[17:28:18.010]         else {
[17:28:18.010]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.010]         }
[17:28:18.010]         base::close(...future.stdout)
[17:28:18.010]         ...future.stdout <- NULL
[17:28:18.010]     }
[17:28:18.010]     ...future.result$conditions <- ...future.conditions
[17:28:18.010]     ...future.result$finished <- base::Sys.time()
[17:28:18.010]     ...future.result
[17:28:18.010] }
[17:28:18.013] assign_globals() ...
[17:28:18.014] List of 1
[17:28:18.014]  $ x: int [1:4] 0 1 2 3
[17:28:18.014]  - attr(*, "where")=List of 1
[17:28:18.014]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.014]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.014]  - attr(*, "resolved")= logi FALSE
[17:28:18.014]  - attr(*, "total_size")= num 64
[17:28:18.014]  - attr(*, "already-done")= logi TRUE
[17:28:18.016] - copied 'x' to environment
[17:28:18.017] assign_globals() ... done
[17:28:18.017] plan(): Setting new future strategy stack:
[17:28:18.017] List of future strategies:
[17:28:18.017] 1. sequential:
[17:28:18.017]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.017]    - tweaked: FALSE
[17:28:18.017]    - call: NULL
[17:28:18.018] plan(): nbrOfWorkers() = 1
[17:28:18.019] plan(): Setting new future strategy stack:
[17:28:18.019] List of future strategies:
[17:28:18.019] 1. sequential:
[17:28:18.019]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.019]    - tweaked: FALSE
[17:28:18.019]    - call: plan(strategy)
[17:28:18.020] plan(): nbrOfWorkers() = 1
[17:28:18.020] SequentialFuture started (and completed)
[17:28:18.020] - Launch lazy future ... done
[17:28:18.020] run() for 'SequentialFuture' ... done
[17:28:18.021] getGlobalsAndPackages() ...
[17:28:18.021] Searching for globals...
[17:28:18.022] - globals found: [3] '{', 'sample', 'x'
[17:28:18.022] Searching for globals ... DONE
[17:28:18.022] Resolving globals: FALSE
[17:28:18.023] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.023] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.023] - globals: [1] 'x'
[17:28:18.024] 
[17:28:18.024] getGlobalsAndPackages() ... DONE
[17:28:18.024] run() for 'Future' ...
[17:28:18.024] - state: 'created'
[17:28:18.025] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.025] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.025] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.025]   - Field: 'label'
[17:28:18.025]   - Field: 'local'
[17:28:18.026]   - Field: 'owner'
[17:28:18.026]   - Field: 'envir'
[17:28:18.026]   - Field: 'packages'
[17:28:18.026]   - Field: 'gc'
[17:28:18.026]   - Field: 'conditions'
[17:28:18.026]   - Field: 'expr'
[17:28:18.027]   - Field: 'uuid'
[17:28:18.027]   - Field: 'seed'
[17:28:18.027]   - Field: 'version'
[17:28:18.027]   - Field: 'result'
[17:28:18.027]   - Field: 'asynchronous'
[17:28:18.027]   - Field: 'calls'
[17:28:18.028]   - Field: 'globals'
[17:28:18.028]   - Field: 'stdout'
[17:28:18.028]   - Field: 'earlySignal'
[17:28:18.028]   - Field: 'lazy'
[17:28:18.028]   - Field: 'state'
[17:28:18.028] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.029] - Launch lazy future ...
[17:28:18.029] Packages needed by the future expression (n = 0): <none>
[17:28:18.029] Packages needed by future strategies (n = 0): <none>
[17:28:18.030] {
[17:28:18.030]     {
[17:28:18.030]         {
[17:28:18.030]             ...future.startTime <- base::Sys.time()
[17:28:18.030]             {
[17:28:18.030]                 {
[17:28:18.030]                   {
[17:28:18.030]                     {
[17:28:18.030]                       base::local({
[17:28:18.030]                         has_future <- base::requireNamespace("future", 
[17:28:18.030]                           quietly = TRUE)
[17:28:18.030]                         if (has_future) {
[17:28:18.030]                           ns <- base::getNamespace("future")
[17:28:18.030]                           version <- ns[[".package"]][["version"]]
[17:28:18.030]                           if (is.null(version)) 
[17:28:18.030]                             version <- utils::packageVersion("future")
[17:28:18.030]                         }
[17:28:18.030]                         else {
[17:28:18.030]                           version <- NULL
[17:28:18.030]                         }
[17:28:18.030]                         if (!has_future || version < "1.8.0") {
[17:28:18.030]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.030]                             "", base::R.version$version.string), 
[17:28:18.030]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:18.030]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.030]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.030]                               "release", "version")], collapse = " "), 
[17:28:18.030]                             hostname = base::Sys.info()[["nodename"]])
[17:28:18.030]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.030]                             info)
[17:28:18.030]                           info <- base::paste(info, collapse = "; ")
[17:28:18.030]                           if (!has_future) {
[17:28:18.030]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.030]                               info)
[17:28:18.030]                           }
[17:28:18.030]                           else {
[17:28:18.030]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.030]                               info, version)
[17:28:18.030]                           }
[17:28:18.030]                           base::stop(msg)
[17:28:18.030]                         }
[17:28:18.030]                       })
[17:28:18.030]                     }
[17:28:18.030]                     ...future.strategy.old <- future::plan("list")
[17:28:18.030]                     options(future.plan = NULL)
[17:28:18.030]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.030]                     future::plan("default", .cleanup = FALSE, 
[17:28:18.030]                       .init = FALSE)
[17:28:18.030]                   }
[17:28:18.030]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:28:18.030]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:28:18.030]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:28:18.030]                 }
[17:28:18.030]                 ...future.workdir <- getwd()
[17:28:18.030]             }
[17:28:18.030]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.030]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.030]         }
[17:28:18.030]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.030]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.030]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.030]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.030]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.030]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.030]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.030]             base::names(...future.oldOptions))
[17:28:18.030]     }
[17:28:18.030]     if (FALSE) {
[17:28:18.030]     }
[17:28:18.030]     else {
[17:28:18.030]         if (TRUE) {
[17:28:18.030]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.030]                 open = "w")
[17:28:18.030]         }
[17:28:18.030]         else {
[17:28:18.030]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.030]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.030]         }
[17:28:18.030]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.030]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.030]             base::sink(type = "output", split = FALSE)
[17:28:18.030]             base::close(...future.stdout)
[17:28:18.030]         }, add = TRUE)
[17:28:18.030]     }
[17:28:18.030]     ...future.frame <- base::sys.nframe()
[17:28:18.030]     ...future.conditions <- base::list()
[17:28:18.030]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.030]     if (FALSE) {
[17:28:18.030]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.030]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.030]     }
[17:28:18.030]     ...future.result <- base::tryCatch({
[17:28:18.030]         base::withCallingHandlers({
[17:28:18.030]             ...future.value <- base::withVisible(base::local({
[17:28:18.030]                 sample(x, size = 1L)
[17:28:18.030]             }))
[17:28:18.030]             future::FutureResult(value = ...future.value$value, 
[17:28:18.030]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.030]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.030]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.030]                     ...future.globalenv.names))
[17:28:18.030]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.030]         }, condition = base::local({
[17:28:18.030]             c <- base::c
[17:28:18.030]             inherits <- base::inherits
[17:28:18.030]             invokeRestart <- base::invokeRestart
[17:28:18.030]             length <- base::length
[17:28:18.030]             list <- base::list
[17:28:18.030]             seq.int <- base::seq.int
[17:28:18.030]             signalCondition <- base::signalCondition
[17:28:18.030]             sys.calls <- base::sys.calls
[17:28:18.030]             `[[` <- base::`[[`
[17:28:18.030]             `+` <- base::`+`
[17:28:18.030]             `<<-` <- base::`<<-`
[17:28:18.030]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.030]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.030]                   3L)]
[17:28:18.030]             }
[17:28:18.030]             function(cond) {
[17:28:18.030]                 is_error <- inherits(cond, "error")
[17:28:18.030]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.030]                   NULL)
[17:28:18.030]                 if (is_error) {
[17:28:18.030]                   sessionInformation <- function() {
[17:28:18.030]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.030]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.030]                       search = base::search(), system = base::Sys.info())
[17:28:18.030]                   }
[17:28:18.030]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.030]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.030]                     cond$call), session = sessionInformation(), 
[17:28:18.030]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.030]                   signalCondition(cond)
[17:28:18.030]                 }
[17:28:18.030]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.030]                 "immediateCondition"))) {
[17:28:18.030]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.030]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.030]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.030]                   if (TRUE && !signal) {
[17:28:18.030]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.030]                     {
[17:28:18.030]                       inherits <- base::inherits
[17:28:18.030]                       invokeRestart <- base::invokeRestart
[17:28:18.030]                       is.null <- base::is.null
[17:28:18.030]                       muffled <- FALSE
[17:28:18.030]                       if (inherits(cond, "message")) {
[17:28:18.030]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.030]                         if (muffled) 
[17:28:18.030]                           invokeRestart("muffleMessage")
[17:28:18.030]                       }
[17:28:18.030]                       else if (inherits(cond, "warning")) {
[17:28:18.030]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.030]                         if (muffled) 
[17:28:18.030]                           invokeRestart("muffleWarning")
[17:28:18.030]                       }
[17:28:18.030]                       else if (inherits(cond, "condition")) {
[17:28:18.030]                         if (!is.null(pattern)) {
[17:28:18.030]                           computeRestarts <- base::computeRestarts
[17:28:18.030]                           grepl <- base::grepl
[17:28:18.030]                           restarts <- computeRestarts(cond)
[17:28:18.030]                           for (restart in restarts) {
[17:28:18.030]                             name <- restart$name
[17:28:18.030]                             if (is.null(name)) 
[17:28:18.030]                               next
[17:28:18.030]                             if (!grepl(pattern, name)) 
[17:28:18.030]                               next
[17:28:18.030]                             invokeRestart(restart)
[17:28:18.030]                             muffled <- TRUE
[17:28:18.030]                             break
[17:28:18.030]                           }
[17:28:18.030]                         }
[17:28:18.030]                       }
[17:28:18.030]                       invisible(muffled)
[17:28:18.030]                     }
[17:28:18.030]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.030]                   }
[17:28:18.030]                 }
[17:28:18.030]                 else {
[17:28:18.030]                   if (TRUE) {
[17:28:18.030]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.030]                     {
[17:28:18.030]                       inherits <- base::inherits
[17:28:18.030]                       invokeRestart <- base::invokeRestart
[17:28:18.030]                       is.null <- base::is.null
[17:28:18.030]                       muffled <- FALSE
[17:28:18.030]                       if (inherits(cond, "message")) {
[17:28:18.030]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.030]                         if (muffled) 
[17:28:18.030]                           invokeRestart("muffleMessage")
[17:28:18.030]                       }
[17:28:18.030]                       else if (inherits(cond, "warning")) {
[17:28:18.030]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.030]                         if (muffled) 
[17:28:18.030]                           invokeRestart("muffleWarning")
[17:28:18.030]                       }
[17:28:18.030]                       else if (inherits(cond, "condition")) {
[17:28:18.030]                         if (!is.null(pattern)) {
[17:28:18.030]                           computeRestarts <- base::computeRestarts
[17:28:18.030]                           grepl <- base::grepl
[17:28:18.030]                           restarts <- computeRestarts(cond)
[17:28:18.030]                           for (restart in restarts) {
[17:28:18.030]                             name <- restart$name
[17:28:18.030]                             if (is.null(name)) 
[17:28:18.030]                               next
[17:28:18.030]                             if (!grepl(pattern, name)) 
[17:28:18.030]                               next
[17:28:18.030]                             invokeRestart(restart)
[17:28:18.030]                             muffled <- TRUE
[17:28:18.030]                             break
[17:28:18.030]                           }
[17:28:18.030]                         }
[17:28:18.030]                       }
[17:28:18.030]                       invisible(muffled)
[17:28:18.030]                     }
[17:28:18.030]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.030]                   }
[17:28:18.030]                 }
[17:28:18.030]             }
[17:28:18.030]         }))
[17:28:18.030]     }, error = function(ex) {
[17:28:18.030]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.030]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.030]                 ...future.rng), started = ...future.startTime, 
[17:28:18.030]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.030]             version = "1.8"), class = "FutureResult")
[17:28:18.030]     }, finally = {
[17:28:18.030]         if (!identical(...future.workdir, getwd())) 
[17:28:18.030]             setwd(...future.workdir)
[17:28:18.030]         {
[17:28:18.030]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.030]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.030]             }
[17:28:18.030]             base::options(...future.oldOptions)
[17:28:18.030]             if (.Platform$OS.type == "windows") {
[17:28:18.030]                 old_names <- names(...future.oldEnvVars)
[17:28:18.030]                 envs <- base::Sys.getenv()
[17:28:18.030]                 names <- names(envs)
[17:28:18.030]                 common <- intersect(names, old_names)
[17:28:18.030]                 added <- setdiff(names, old_names)
[17:28:18.030]                 removed <- setdiff(old_names, names)
[17:28:18.030]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.030]                   envs[common]]
[17:28:18.030]                 NAMES <- toupper(changed)
[17:28:18.030]                 args <- list()
[17:28:18.030]                 for (kk in seq_along(NAMES)) {
[17:28:18.030]                   name <- changed[[kk]]
[17:28:18.030]                   NAME <- NAMES[[kk]]
[17:28:18.030]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.030]                     next
[17:28:18.030]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.030]                 }
[17:28:18.030]                 NAMES <- toupper(added)
[17:28:18.030]                 for (kk in seq_along(NAMES)) {
[17:28:18.030]                   name <- added[[kk]]
[17:28:18.030]                   NAME <- NAMES[[kk]]
[17:28:18.030]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.030]                     next
[17:28:18.030]                   args[[name]] <- ""
[17:28:18.030]                 }
[17:28:18.030]                 NAMES <- toupper(removed)
[17:28:18.030]                 for (kk in seq_along(NAMES)) {
[17:28:18.030]                   name <- removed[[kk]]
[17:28:18.030]                   NAME <- NAMES[[kk]]
[17:28:18.030]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.030]                     next
[17:28:18.030]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.030]                 }
[17:28:18.030]                 if (length(args) > 0) 
[17:28:18.030]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.030]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.030]             }
[17:28:18.030]             else {
[17:28:18.030]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.030]             }
[17:28:18.030]             {
[17:28:18.030]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.030]                   0L) {
[17:28:18.030]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.030]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.030]                   base::options(opts)
[17:28:18.030]                 }
[17:28:18.030]                 {
[17:28:18.030]                   {
[17:28:18.030]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:18.030]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:18.030]                     -1344458670L), envir = base::globalenv(), 
[17:28:18.030]                       inherits = FALSE)
[17:28:18.030]                     NULL
[17:28:18.030]                   }
[17:28:18.030]                   options(future.plan = NULL)
[17:28:18.030]                   if (is.na(NA_character_)) 
[17:28:18.030]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.030]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.030]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.030]                     .init = FALSE)
[17:28:18.030]                 }
[17:28:18.030]             }
[17:28:18.030]         }
[17:28:18.030]     })
[17:28:18.030]     if (TRUE) {
[17:28:18.030]         base::sink(type = "output", split = FALSE)
[17:28:18.030]         if (TRUE) {
[17:28:18.030]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.030]         }
[17:28:18.030]         else {
[17:28:18.030]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.030]         }
[17:28:18.030]         base::close(...future.stdout)
[17:28:18.030]         ...future.stdout <- NULL
[17:28:18.030]     }
[17:28:18.030]     ...future.result$conditions <- ...future.conditions
[17:28:18.030]     ...future.result$finished <- base::Sys.time()
[17:28:18.030]     ...future.result
[17:28:18.030] }
[17:28:18.033] assign_globals() ...
[17:28:18.033] List of 1
[17:28:18.033]  $ x: int [1:4] 0 1 2 3
[17:28:18.033]  - attr(*, "where")=List of 1
[17:28:18.033]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.033]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.033]  - attr(*, "resolved")= logi FALSE
[17:28:18.033]  - attr(*, "total_size")= num 64
[17:28:18.033]  - attr(*, "already-done")= logi TRUE
[17:28:18.036] - copied 'x' to environment
[17:28:18.037] assign_globals() ... done
[17:28:18.037] plan(): Setting new future strategy stack:
[17:28:18.037] List of future strategies:
[17:28:18.037] 1. sequential:
[17:28:18.037]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.037]    - tweaked: FALSE
[17:28:18.037]    - call: NULL
[17:28:18.038] plan(): nbrOfWorkers() = 1
[17:28:18.039] plan(): Setting new future strategy stack:
[17:28:18.039] List of future strategies:
[17:28:18.039] 1. sequential:
[17:28:18.039]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.039]    - tweaked: FALSE
[17:28:18.039]    - call: plan(strategy)
[17:28:18.040] plan(): nbrOfWorkers() = 1
[17:28:18.041] SequentialFuture started (and completed)
[17:28:18.041] - Launch lazy future ... done
[17:28:18.041] run() for 'SequentialFuture' ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[17:28:18.042] getGlobalsAndPackages() ...
[17:28:18.042] Searching for globals...
[17:28:18.044] - globals found: [3] '{', 'sample', 'x'
[17:28:18.044] Searching for globals ... DONE
[17:28:18.044] Resolving globals: FALSE
[17:28:18.044] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.045] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.045] - globals: [1] 'x'
[17:28:18.045] 
[17:28:18.045] getGlobalsAndPackages() ... DONE
[17:28:18.046] run() for 'Future' ...
[17:28:18.046] - state: 'created'
[17:28:18.046] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.047] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.047] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.047]   - Field: 'label'
[17:28:18.047]   - Field: 'local'
[17:28:18.047]   - Field: 'owner'
[17:28:18.047]   - Field: 'envir'
[17:28:18.048]   - Field: 'packages'
[17:28:18.048]   - Field: 'gc'
[17:28:18.048]   - Field: 'conditions'
[17:28:18.048]   - Field: 'expr'
[17:28:18.048]   - Field: 'uuid'
[17:28:18.048]   - Field: 'seed'
[17:28:18.049]   - Field: 'version'
[17:28:18.049]   - Field: 'result'
[17:28:18.049]   - Field: 'asynchronous'
[17:28:18.049]   - Field: 'calls'
[17:28:18.049]   - Field: 'globals'
[17:28:18.050]   - Field: 'stdout'
[17:28:18.050]   - Field: 'earlySignal'
[17:28:18.050]   - Field: 'lazy'
[17:28:18.050]   - Field: 'state'
[17:28:18.050] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.050] - Launch lazy future ...
[17:28:18.051] Packages needed by the future expression (n = 0): <none>
[17:28:18.051] Packages needed by future strategies (n = 0): <none>
[17:28:18.051] {
[17:28:18.051]     {
[17:28:18.051]         {
[17:28:18.051]             ...future.startTime <- base::Sys.time()
[17:28:18.051]             {
[17:28:18.051]                 {
[17:28:18.051]                   {
[17:28:18.051]                     {
[17:28:18.051]                       base::local({
[17:28:18.051]                         has_future <- base::requireNamespace("future", 
[17:28:18.051]                           quietly = TRUE)
[17:28:18.051]                         if (has_future) {
[17:28:18.051]                           ns <- base::getNamespace("future")
[17:28:18.051]                           version <- ns[[".package"]][["version"]]
[17:28:18.051]                           if (is.null(version)) 
[17:28:18.051]                             version <- utils::packageVersion("future")
[17:28:18.051]                         }
[17:28:18.051]                         else {
[17:28:18.051]                           version <- NULL
[17:28:18.051]                         }
[17:28:18.051]                         if (!has_future || version < "1.8.0") {
[17:28:18.051]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.051]                             "", base::R.version$version.string), 
[17:28:18.051]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:18.051]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.051]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.051]                               "release", "version")], collapse = " "), 
[17:28:18.051]                             hostname = base::Sys.info()[["nodename"]])
[17:28:18.051]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.051]                             info)
[17:28:18.051]                           info <- base::paste(info, collapse = "; ")
[17:28:18.051]                           if (!has_future) {
[17:28:18.051]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.051]                               info)
[17:28:18.051]                           }
[17:28:18.051]                           else {
[17:28:18.051]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.051]                               info, version)
[17:28:18.051]                           }
[17:28:18.051]                           base::stop(msg)
[17:28:18.051]                         }
[17:28:18.051]                       })
[17:28:18.051]                     }
[17:28:18.051]                     ...future.strategy.old <- future::plan("list")
[17:28:18.051]                     options(future.plan = NULL)
[17:28:18.051]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.051]                     future::plan("default", .cleanup = FALSE, 
[17:28:18.051]                       .init = FALSE)
[17:28:18.051]                   }
[17:28:18.051]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:28:18.051]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:28:18.051]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:28:18.051]                 }
[17:28:18.051]                 ...future.workdir <- getwd()
[17:28:18.051]             }
[17:28:18.051]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.051]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.051]         }
[17:28:18.051]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.051]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.051]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.051]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.051]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.051]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.051]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.051]             base::names(...future.oldOptions))
[17:28:18.051]     }
[17:28:18.051]     if (FALSE) {
[17:28:18.051]     }
[17:28:18.051]     else {
[17:28:18.051]         if (TRUE) {
[17:28:18.051]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.051]                 open = "w")
[17:28:18.051]         }
[17:28:18.051]         else {
[17:28:18.051]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.051]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.051]         }
[17:28:18.051]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.051]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.051]             base::sink(type = "output", split = FALSE)
[17:28:18.051]             base::close(...future.stdout)
[17:28:18.051]         }, add = TRUE)
[17:28:18.051]     }
[17:28:18.051]     ...future.frame <- base::sys.nframe()
[17:28:18.051]     ...future.conditions <- base::list()
[17:28:18.051]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.051]     if (FALSE) {
[17:28:18.051]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.051]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.051]     }
[17:28:18.051]     ...future.result <- base::tryCatch({
[17:28:18.051]         base::withCallingHandlers({
[17:28:18.051]             ...future.value <- base::withVisible(base::local({
[17:28:18.051]                 sample(x, size = 1L)
[17:28:18.051]             }))
[17:28:18.051]             future::FutureResult(value = ...future.value$value, 
[17:28:18.051]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.051]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.051]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.051]                     ...future.globalenv.names))
[17:28:18.051]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.051]         }, condition = base::local({
[17:28:18.051]             c <- base::c
[17:28:18.051]             inherits <- base::inherits
[17:28:18.051]             invokeRestart <- base::invokeRestart
[17:28:18.051]             length <- base::length
[17:28:18.051]             list <- base::list
[17:28:18.051]             seq.int <- base::seq.int
[17:28:18.051]             signalCondition <- base::signalCondition
[17:28:18.051]             sys.calls <- base::sys.calls
[17:28:18.051]             `[[` <- base::`[[`
[17:28:18.051]             `+` <- base::`+`
[17:28:18.051]             `<<-` <- base::`<<-`
[17:28:18.051]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.051]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.051]                   3L)]
[17:28:18.051]             }
[17:28:18.051]             function(cond) {
[17:28:18.051]                 is_error <- inherits(cond, "error")
[17:28:18.051]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.051]                   NULL)
[17:28:18.051]                 if (is_error) {
[17:28:18.051]                   sessionInformation <- function() {
[17:28:18.051]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.051]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.051]                       search = base::search(), system = base::Sys.info())
[17:28:18.051]                   }
[17:28:18.051]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.051]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.051]                     cond$call), session = sessionInformation(), 
[17:28:18.051]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.051]                   signalCondition(cond)
[17:28:18.051]                 }
[17:28:18.051]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.051]                 "immediateCondition"))) {
[17:28:18.051]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.051]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.051]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.051]                   if (TRUE && !signal) {
[17:28:18.051]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.051]                     {
[17:28:18.051]                       inherits <- base::inherits
[17:28:18.051]                       invokeRestart <- base::invokeRestart
[17:28:18.051]                       is.null <- base::is.null
[17:28:18.051]                       muffled <- FALSE
[17:28:18.051]                       if (inherits(cond, "message")) {
[17:28:18.051]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.051]                         if (muffled) 
[17:28:18.051]                           invokeRestart("muffleMessage")
[17:28:18.051]                       }
[17:28:18.051]                       else if (inherits(cond, "warning")) {
[17:28:18.051]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.051]                         if (muffled) 
[17:28:18.051]                           invokeRestart("muffleWarning")
[17:28:18.051]                       }
[17:28:18.051]                       else if (inherits(cond, "condition")) {
[17:28:18.051]                         if (!is.null(pattern)) {
[17:28:18.051]                           computeRestarts <- base::computeRestarts
[17:28:18.051]                           grepl <- base::grepl
[17:28:18.051]                           restarts <- computeRestarts(cond)
[17:28:18.051]                           for (restart in restarts) {
[17:28:18.051]                             name <- restart$name
[17:28:18.051]                             if (is.null(name)) 
[17:28:18.051]                               next
[17:28:18.051]                             if (!grepl(pattern, name)) 
[17:28:18.051]                               next
[17:28:18.051]                             invokeRestart(restart)
[17:28:18.051]                             muffled <- TRUE
[17:28:18.051]                             break
[17:28:18.051]                           }
[17:28:18.051]                         }
[17:28:18.051]                       }
[17:28:18.051]                       invisible(muffled)
[17:28:18.051]                     }
[17:28:18.051]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.051]                   }
[17:28:18.051]                 }
[17:28:18.051]                 else {
[17:28:18.051]                   if (TRUE) {
[17:28:18.051]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.051]                     {
[17:28:18.051]                       inherits <- base::inherits
[17:28:18.051]                       invokeRestart <- base::invokeRestart
[17:28:18.051]                       is.null <- base::is.null
[17:28:18.051]                       muffled <- FALSE
[17:28:18.051]                       if (inherits(cond, "message")) {
[17:28:18.051]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.051]                         if (muffled) 
[17:28:18.051]                           invokeRestart("muffleMessage")
[17:28:18.051]                       }
[17:28:18.051]                       else if (inherits(cond, "warning")) {
[17:28:18.051]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.051]                         if (muffled) 
[17:28:18.051]                           invokeRestart("muffleWarning")
[17:28:18.051]                       }
[17:28:18.051]                       else if (inherits(cond, "condition")) {
[17:28:18.051]                         if (!is.null(pattern)) {
[17:28:18.051]                           computeRestarts <- base::computeRestarts
[17:28:18.051]                           grepl <- base::grepl
[17:28:18.051]                           restarts <- computeRestarts(cond)
[17:28:18.051]                           for (restart in restarts) {
[17:28:18.051]                             name <- restart$name
[17:28:18.051]                             if (is.null(name)) 
[17:28:18.051]                               next
[17:28:18.051]                             if (!grepl(pattern, name)) 
[17:28:18.051]                               next
[17:28:18.051]                             invokeRestart(restart)
[17:28:18.051]                             muffled <- TRUE
[17:28:18.051]                             break
[17:28:18.051]                           }
[17:28:18.051]                         }
[17:28:18.051]                       }
[17:28:18.051]                       invisible(muffled)
[17:28:18.051]                     }
[17:28:18.051]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.051]                   }
[17:28:18.051]                 }
[17:28:18.051]             }
[17:28:18.051]         }))
[17:28:18.051]     }, error = function(ex) {
[17:28:18.051]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.051]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.051]                 ...future.rng), started = ...future.startTime, 
[17:28:18.051]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.051]             version = "1.8"), class = "FutureResult")
[17:28:18.051]     }, finally = {
[17:28:18.051]         if (!identical(...future.workdir, getwd())) 
[17:28:18.051]             setwd(...future.workdir)
[17:28:18.051]         {
[17:28:18.051]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.051]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.051]             }
[17:28:18.051]             base::options(...future.oldOptions)
[17:28:18.051]             if (.Platform$OS.type == "windows") {
[17:28:18.051]                 old_names <- names(...future.oldEnvVars)
[17:28:18.051]                 envs <- base::Sys.getenv()
[17:28:18.051]                 names <- names(envs)
[17:28:18.051]                 common <- intersect(names, old_names)
[17:28:18.051]                 added <- setdiff(names, old_names)
[17:28:18.051]                 removed <- setdiff(old_names, names)
[17:28:18.051]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.051]                   envs[common]]
[17:28:18.051]                 NAMES <- toupper(changed)
[17:28:18.051]                 args <- list()
[17:28:18.051]                 for (kk in seq_along(NAMES)) {
[17:28:18.051]                   name <- changed[[kk]]
[17:28:18.051]                   NAME <- NAMES[[kk]]
[17:28:18.051]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.051]                     next
[17:28:18.051]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.051]                 }
[17:28:18.051]                 NAMES <- toupper(added)
[17:28:18.051]                 for (kk in seq_along(NAMES)) {
[17:28:18.051]                   name <- added[[kk]]
[17:28:18.051]                   NAME <- NAMES[[kk]]
[17:28:18.051]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.051]                     next
[17:28:18.051]                   args[[name]] <- ""
[17:28:18.051]                 }
[17:28:18.051]                 NAMES <- toupper(removed)
[17:28:18.051]                 for (kk in seq_along(NAMES)) {
[17:28:18.051]                   name <- removed[[kk]]
[17:28:18.051]                   NAME <- NAMES[[kk]]
[17:28:18.051]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.051]                     next
[17:28:18.051]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.051]                 }
[17:28:18.051]                 if (length(args) > 0) 
[17:28:18.051]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.051]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.051]             }
[17:28:18.051]             else {
[17:28:18.051]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.051]             }
[17:28:18.051]             {
[17:28:18.051]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.051]                   0L) {
[17:28:18.051]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.051]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.051]                   base::options(opts)
[17:28:18.051]                 }
[17:28:18.051]                 {
[17:28:18.051]                   {
[17:28:18.051]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:18.051]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:18.051]                     -1344458670L), envir = base::globalenv(), 
[17:28:18.051]                       inherits = FALSE)
[17:28:18.051]                     NULL
[17:28:18.051]                   }
[17:28:18.051]                   options(future.plan = NULL)
[17:28:18.051]                   if (is.na(NA_character_)) 
[17:28:18.051]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.051]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.051]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.051]                     .init = FALSE)
[17:28:18.051]                 }
[17:28:18.051]             }
[17:28:18.051]         }
[17:28:18.051]     })
[17:28:18.051]     if (TRUE) {
[17:28:18.051]         base::sink(type = "output", split = FALSE)
[17:28:18.051]         if (TRUE) {
[17:28:18.051]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.051]         }
[17:28:18.051]         else {
[17:28:18.051]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.051]         }
[17:28:18.051]         base::close(...future.stdout)
[17:28:18.051]         ...future.stdout <- NULL
[17:28:18.051]     }
[17:28:18.051]     ...future.result$conditions <- ...future.conditions
[17:28:18.051]     ...future.result$finished <- base::Sys.time()
[17:28:18.051]     ...future.result
[17:28:18.051] }
[17:28:18.055] assign_globals() ...
[17:28:18.055] List of 1
[17:28:18.055]  $ x: int [1:4] 0 1 2 3
[17:28:18.055]  - attr(*, "where")=List of 1
[17:28:18.055]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.055]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.055]  - attr(*, "resolved")= logi FALSE
[17:28:18.055]  - attr(*, "total_size")= num 64
[17:28:18.055]  - attr(*, "already-done")= logi TRUE
[17:28:18.058] - copied 'x' to environment
[17:28:18.058] assign_globals() ... done
[17:28:18.059] plan(): Setting new future strategy stack:
[17:28:18.059] List of future strategies:
[17:28:18.059] 1. sequential:
[17:28:18.059]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.059]    - tweaked: FALSE
[17:28:18.059]    - call: NULL
[17:28:18.059] plan(): nbrOfWorkers() = 1
[17:28:18.061] plan(): Setting new future strategy stack:
[17:28:18.061] List of future strategies:
[17:28:18.061] 1. sequential:
[17:28:18.061]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.061]    - tweaked: FALSE
[17:28:18.061]    - call: plan(strategy)
[17:28:18.061] plan(): nbrOfWorkers() = 1
[17:28:18.062] SequentialFuture started (and completed)
[17:28:18.062] - Launch lazy future ... done
[17:28:18.062] run() for 'SequentialFuture' ... done
[17:28:18.062] getGlobalsAndPackages() ...
[17:28:18.063] Searching for globals...
[17:28:18.064] - globals found: [3] '{', 'sample', 'x'
[17:28:18.064] Searching for globals ... DONE
[17:28:18.064] Resolving globals: FALSE
[17:28:18.065] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.065] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.065] - globals: [1] 'x'
[17:28:18.065] 
[17:28:18.065] getGlobalsAndPackages() ... DONE
[17:28:18.066] run() for 'Future' ...
[17:28:18.066] - state: 'created'
[17:28:18.066] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.067] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.067] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.067]   - Field: 'label'
[17:28:18.067]   - Field: 'local'
[17:28:18.067]   - Field: 'owner'
[17:28:18.067]   - Field: 'envir'
[17:28:18.068]   - Field: 'packages'
[17:28:18.068]   - Field: 'gc'
[17:28:18.068]   - Field: 'conditions'
[17:28:18.068]   - Field: 'expr'
[17:28:18.068]   - Field: 'uuid'
[17:28:18.068]   - Field: 'seed'
[17:28:18.069]   - Field: 'version'
[17:28:18.069]   - Field: 'result'
[17:28:18.069]   - Field: 'asynchronous'
[17:28:18.069]   - Field: 'calls'
[17:28:18.069]   - Field: 'globals'
[17:28:18.069]   - Field: 'stdout'
[17:28:18.071]   - Field: 'earlySignal'
[17:28:18.071]   - Field: 'lazy'
[17:28:18.071]   - Field: 'state'
[17:28:18.071] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.071] - Launch lazy future ...
[17:28:18.071] Packages needed by the future expression (n = 0): <none>
[17:28:18.072] Packages needed by future strategies (n = 0): <none>
[17:28:18.072] {
[17:28:18.072]     {
[17:28:18.072]         {
[17:28:18.072]             ...future.startTime <- base::Sys.time()
[17:28:18.072]             {
[17:28:18.072]                 {
[17:28:18.072]                   {
[17:28:18.072]                     {
[17:28:18.072]                       base::local({
[17:28:18.072]                         has_future <- base::requireNamespace("future", 
[17:28:18.072]                           quietly = TRUE)
[17:28:18.072]                         if (has_future) {
[17:28:18.072]                           ns <- base::getNamespace("future")
[17:28:18.072]                           version <- ns[[".package"]][["version"]]
[17:28:18.072]                           if (is.null(version)) 
[17:28:18.072]                             version <- utils::packageVersion("future")
[17:28:18.072]                         }
[17:28:18.072]                         else {
[17:28:18.072]                           version <- NULL
[17:28:18.072]                         }
[17:28:18.072]                         if (!has_future || version < "1.8.0") {
[17:28:18.072]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.072]                             "", base::R.version$version.string), 
[17:28:18.072]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:18.072]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.072]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.072]                               "release", "version")], collapse = " "), 
[17:28:18.072]                             hostname = base::Sys.info()[["nodename"]])
[17:28:18.072]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.072]                             info)
[17:28:18.072]                           info <- base::paste(info, collapse = "; ")
[17:28:18.072]                           if (!has_future) {
[17:28:18.072]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.072]                               info)
[17:28:18.072]                           }
[17:28:18.072]                           else {
[17:28:18.072]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.072]                               info, version)
[17:28:18.072]                           }
[17:28:18.072]                           base::stop(msg)
[17:28:18.072]                         }
[17:28:18.072]                       })
[17:28:18.072]                     }
[17:28:18.072]                     ...future.strategy.old <- future::plan("list")
[17:28:18.072]                     options(future.plan = NULL)
[17:28:18.072]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.072]                     future::plan("default", .cleanup = FALSE, 
[17:28:18.072]                       .init = FALSE)
[17:28:18.072]                   }
[17:28:18.072]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:28:18.072]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:28:18.072]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:28:18.072]                 }
[17:28:18.072]                 ...future.workdir <- getwd()
[17:28:18.072]             }
[17:28:18.072]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.072]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.072]         }
[17:28:18.072]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.072]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.072]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.072]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.072]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.072]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.072]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.072]             base::names(...future.oldOptions))
[17:28:18.072]     }
[17:28:18.072]     if (FALSE) {
[17:28:18.072]     }
[17:28:18.072]     else {
[17:28:18.072]         if (TRUE) {
[17:28:18.072]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.072]                 open = "w")
[17:28:18.072]         }
[17:28:18.072]         else {
[17:28:18.072]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.072]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.072]         }
[17:28:18.072]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.072]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.072]             base::sink(type = "output", split = FALSE)
[17:28:18.072]             base::close(...future.stdout)
[17:28:18.072]         }, add = TRUE)
[17:28:18.072]     }
[17:28:18.072]     ...future.frame <- base::sys.nframe()
[17:28:18.072]     ...future.conditions <- base::list()
[17:28:18.072]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.072]     if (FALSE) {
[17:28:18.072]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.072]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.072]     }
[17:28:18.072]     ...future.result <- base::tryCatch({
[17:28:18.072]         base::withCallingHandlers({
[17:28:18.072]             ...future.value <- base::withVisible(base::local({
[17:28:18.072]                 sample(x, size = 1L)
[17:28:18.072]             }))
[17:28:18.072]             future::FutureResult(value = ...future.value$value, 
[17:28:18.072]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.072]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.072]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.072]                     ...future.globalenv.names))
[17:28:18.072]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.072]         }, condition = base::local({
[17:28:18.072]             c <- base::c
[17:28:18.072]             inherits <- base::inherits
[17:28:18.072]             invokeRestart <- base::invokeRestart
[17:28:18.072]             length <- base::length
[17:28:18.072]             list <- base::list
[17:28:18.072]             seq.int <- base::seq.int
[17:28:18.072]             signalCondition <- base::signalCondition
[17:28:18.072]             sys.calls <- base::sys.calls
[17:28:18.072]             `[[` <- base::`[[`
[17:28:18.072]             `+` <- base::`+`
[17:28:18.072]             `<<-` <- base::`<<-`
[17:28:18.072]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.072]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.072]                   3L)]
[17:28:18.072]             }
[17:28:18.072]             function(cond) {
[17:28:18.072]                 is_error <- inherits(cond, "error")
[17:28:18.072]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.072]                   NULL)
[17:28:18.072]                 if (is_error) {
[17:28:18.072]                   sessionInformation <- function() {
[17:28:18.072]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.072]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.072]                       search = base::search(), system = base::Sys.info())
[17:28:18.072]                   }
[17:28:18.072]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.072]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.072]                     cond$call), session = sessionInformation(), 
[17:28:18.072]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.072]                   signalCondition(cond)
[17:28:18.072]                 }
[17:28:18.072]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.072]                 "immediateCondition"))) {
[17:28:18.072]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.072]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.072]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.072]                   if (TRUE && !signal) {
[17:28:18.072]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.072]                     {
[17:28:18.072]                       inherits <- base::inherits
[17:28:18.072]                       invokeRestart <- base::invokeRestart
[17:28:18.072]                       is.null <- base::is.null
[17:28:18.072]                       muffled <- FALSE
[17:28:18.072]                       if (inherits(cond, "message")) {
[17:28:18.072]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.072]                         if (muffled) 
[17:28:18.072]                           invokeRestart("muffleMessage")
[17:28:18.072]                       }
[17:28:18.072]                       else if (inherits(cond, "warning")) {
[17:28:18.072]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.072]                         if (muffled) 
[17:28:18.072]                           invokeRestart("muffleWarning")
[17:28:18.072]                       }
[17:28:18.072]                       else if (inherits(cond, "condition")) {
[17:28:18.072]                         if (!is.null(pattern)) {
[17:28:18.072]                           computeRestarts <- base::computeRestarts
[17:28:18.072]                           grepl <- base::grepl
[17:28:18.072]                           restarts <- computeRestarts(cond)
[17:28:18.072]                           for (restart in restarts) {
[17:28:18.072]                             name <- restart$name
[17:28:18.072]                             if (is.null(name)) 
[17:28:18.072]                               next
[17:28:18.072]                             if (!grepl(pattern, name)) 
[17:28:18.072]                               next
[17:28:18.072]                             invokeRestart(restart)
[17:28:18.072]                             muffled <- TRUE
[17:28:18.072]                             break
[17:28:18.072]                           }
[17:28:18.072]                         }
[17:28:18.072]                       }
[17:28:18.072]                       invisible(muffled)
[17:28:18.072]                     }
[17:28:18.072]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.072]                   }
[17:28:18.072]                 }
[17:28:18.072]                 else {
[17:28:18.072]                   if (TRUE) {
[17:28:18.072]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.072]                     {
[17:28:18.072]                       inherits <- base::inherits
[17:28:18.072]                       invokeRestart <- base::invokeRestart
[17:28:18.072]                       is.null <- base::is.null
[17:28:18.072]                       muffled <- FALSE
[17:28:18.072]                       if (inherits(cond, "message")) {
[17:28:18.072]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.072]                         if (muffled) 
[17:28:18.072]                           invokeRestart("muffleMessage")
[17:28:18.072]                       }
[17:28:18.072]                       else if (inherits(cond, "warning")) {
[17:28:18.072]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.072]                         if (muffled) 
[17:28:18.072]                           invokeRestart("muffleWarning")
[17:28:18.072]                       }
[17:28:18.072]                       else if (inherits(cond, "condition")) {
[17:28:18.072]                         if (!is.null(pattern)) {
[17:28:18.072]                           computeRestarts <- base::computeRestarts
[17:28:18.072]                           grepl <- base::grepl
[17:28:18.072]                           restarts <- computeRestarts(cond)
[17:28:18.072]                           for (restart in restarts) {
[17:28:18.072]                             name <- restart$name
[17:28:18.072]                             if (is.null(name)) 
[17:28:18.072]                               next
[17:28:18.072]                             if (!grepl(pattern, name)) 
[17:28:18.072]                               next
[17:28:18.072]                             invokeRestart(restart)
[17:28:18.072]                             muffled <- TRUE
[17:28:18.072]                             break
[17:28:18.072]                           }
[17:28:18.072]                         }
[17:28:18.072]                       }
[17:28:18.072]                       invisible(muffled)
[17:28:18.072]                     }
[17:28:18.072]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.072]                   }
[17:28:18.072]                 }
[17:28:18.072]             }
[17:28:18.072]         }))
[17:28:18.072]     }, error = function(ex) {
[17:28:18.072]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.072]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.072]                 ...future.rng), started = ...future.startTime, 
[17:28:18.072]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.072]             version = "1.8"), class = "FutureResult")
[17:28:18.072]     }, finally = {
[17:28:18.072]         if (!identical(...future.workdir, getwd())) 
[17:28:18.072]             setwd(...future.workdir)
[17:28:18.072]         {
[17:28:18.072]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.072]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.072]             }
[17:28:18.072]             base::options(...future.oldOptions)
[17:28:18.072]             if (.Platform$OS.type == "windows") {
[17:28:18.072]                 old_names <- names(...future.oldEnvVars)
[17:28:18.072]                 envs <- base::Sys.getenv()
[17:28:18.072]                 names <- names(envs)
[17:28:18.072]                 common <- intersect(names, old_names)
[17:28:18.072]                 added <- setdiff(names, old_names)
[17:28:18.072]                 removed <- setdiff(old_names, names)
[17:28:18.072]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.072]                   envs[common]]
[17:28:18.072]                 NAMES <- toupper(changed)
[17:28:18.072]                 args <- list()
[17:28:18.072]                 for (kk in seq_along(NAMES)) {
[17:28:18.072]                   name <- changed[[kk]]
[17:28:18.072]                   NAME <- NAMES[[kk]]
[17:28:18.072]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.072]                     next
[17:28:18.072]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.072]                 }
[17:28:18.072]                 NAMES <- toupper(added)
[17:28:18.072]                 for (kk in seq_along(NAMES)) {
[17:28:18.072]                   name <- added[[kk]]
[17:28:18.072]                   NAME <- NAMES[[kk]]
[17:28:18.072]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.072]                     next
[17:28:18.072]                   args[[name]] <- ""
[17:28:18.072]                 }
[17:28:18.072]                 NAMES <- toupper(removed)
[17:28:18.072]                 for (kk in seq_along(NAMES)) {
[17:28:18.072]                   name <- removed[[kk]]
[17:28:18.072]                   NAME <- NAMES[[kk]]
[17:28:18.072]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.072]                     next
[17:28:18.072]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.072]                 }
[17:28:18.072]                 if (length(args) > 0) 
[17:28:18.072]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.072]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.072]             }
[17:28:18.072]             else {
[17:28:18.072]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.072]             }
[17:28:18.072]             {
[17:28:18.072]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.072]                   0L) {
[17:28:18.072]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.072]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.072]                   base::options(opts)
[17:28:18.072]                 }
[17:28:18.072]                 {
[17:28:18.072]                   {
[17:28:18.072]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:18.072]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:18.072]                     -1344458670L), envir = base::globalenv(), 
[17:28:18.072]                       inherits = FALSE)
[17:28:18.072]                     NULL
[17:28:18.072]                   }
[17:28:18.072]                   options(future.plan = NULL)
[17:28:18.072]                   if (is.na(NA_character_)) 
[17:28:18.072]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.072]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.072]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.072]                     .init = FALSE)
[17:28:18.072]                 }
[17:28:18.072]             }
[17:28:18.072]         }
[17:28:18.072]     })
[17:28:18.072]     if (TRUE) {
[17:28:18.072]         base::sink(type = "output", split = FALSE)
[17:28:18.072]         if (TRUE) {
[17:28:18.072]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.072]         }
[17:28:18.072]         else {
[17:28:18.072]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.072]         }
[17:28:18.072]         base::close(...future.stdout)
[17:28:18.072]         ...future.stdout <- NULL
[17:28:18.072]     }
[17:28:18.072]     ...future.result$conditions <- ...future.conditions
[17:28:18.072]     ...future.result$finished <- base::Sys.time()
[17:28:18.072]     ...future.result
[17:28:18.072] }
[17:28:18.076] assign_globals() ...
[17:28:18.076] List of 1
[17:28:18.076]  $ x: int [1:4] 0 1 2 3
[17:28:18.076]  - attr(*, "where")=List of 1
[17:28:18.076]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.076]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.076]  - attr(*, "resolved")= logi FALSE
[17:28:18.076]  - attr(*, "total_size")= num 64
[17:28:18.076]  - attr(*, "already-done")= logi TRUE
[17:28:18.079] - copied 'x' to environment
[17:28:18.079] assign_globals() ... done
[17:28:18.080] plan(): Setting new future strategy stack:
[17:28:18.080] List of future strategies:
[17:28:18.080] 1. sequential:
[17:28:18.080]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.080]    - tweaked: FALSE
[17:28:18.080]    - call: NULL
[17:28:18.080] plan(): nbrOfWorkers() = 1
[17:28:18.082] plan(): Setting new future strategy stack:
[17:28:18.082] List of future strategies:
[17:28:18.082] 1. sequential:
[17:28:18.082]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.082]    - tweaked: FALSE
[17:28:18.082]    - call: plan(strategy)
[17:28:18.082] plan(): nbrOfWorkers() = 1
[17:28:18.083] SequentialFuture started (and completed)
[17:28:18.083] - Launch lazy future ... done
[17:28:18.083] run() for 'SequentialFuture' ... done
[17:28:18.083] getGlobalsAndPackages() ...
[17:28:18.084] Searching for globals...
[17:28:18.085] - globals found: [3] '{', 'sample', 'x'
[17:28:18.085] Searching for globals ... DONE
[17:28:18.085] Resolving globals: FALSE
[17:28:18.086] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.086] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.086] - globals: [1] 'x'
[17:28:18.086] 
[17:28:18.086] getGlobalsAndPackages() ... DONE
[17:28:18.087] run() for 'Future' ...
[17:28:18.087] - state: 'created'
[17:28:18.087] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.088] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.088] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.088]   - Field: 'label'
[17:28:18.088]   - Field: 'local'
[17:28:18.088]   - Field: 'owner'
[17:28:18.088]   - Field: 'envir'
[17:28:18.089]   - Field: 'packages'
[17:28:18.089]   - Field: 'gc'
[17:28:18.089]   - Field: 'conditions'
[17:28:18.089]   - Field: 'expr'
[17:28:18.089]   - Field: 'uuid'
[17:28:18.089]   - Field: 'seed'
[17:28:18.090]   - Field: 'version'
[17:28:18.090]   - Field: 'result'
[17:28:18.090]   - Field: 'asynchronous'
[17:28:18.090]   - Field: 'calls'
[17:28:18.090]   - Field: 'globals'
[17:28:18.090]   - Field: 'stdout'
[17:28:18.091]   - Field: 'earlySignal'
[17:28:18.091]   - Field: 'lazy'
[17:28:18.091]   - Field: 'state'
[17:28:18.091] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.091] - Launch lazy future ...
[17:28:18.092] Packages needed by the future expression (n = 0): <none>
[17:28:18.092] Packages needed by future strategies (n = 0): <none>
[17:28:18.092] {
[17:28:18.092]     {
[17:28:18.092]         {
[17:28:18.092]             ...future.startTime <- base::Sys.time()
[17:28:18.092]             {
[17:28:18.092]                 {
[17:28:18.092]                   {
[17:28:18.092]                     {
[17:28:18.092]                       base::local({
[17:28:18.092]                         has_future <- base::requireNamespace("future", 
[17:28:18.092]                           quietly = TRUE)
[17:28:18.092]                         if (has_future) {
[17:28:18.092]                           ns <- base::getNamespace("future")
[17:28:18.092]                           version <- ns[[".package"]][["version"]]
[17:28:18.092]                           if (is.null(version)) 
[17:28:18.092]                             version <- utils::packageVersion("future")
[17:28:18.092]                         }
[17:28:18.092]                         else {
[17:28:18.092]                           version <- NULL
[17:28:18.092]                         }
[17:28:18.092]                         if (!has_future || version < "1.8.0") {
[17:28:18.092]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.092]                             "", base::R.version$version.string), 
[17:28:18.092]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:18.092]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.092]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.092]                               "release", "version")], collapse = " "), 
[17:28:18.092]                             hostname = base::Sys.info()[["nodename"]])
[17:28:18.092]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.092]                             info)
[17:28:18.092]                           info <- base::paste(info, collapse = "; ")
[17:28:18.092]                           if (!has_future) {
[17:28:18.092]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.092]                               info)
[17:28:18.092]                           }
[17:28:18.092]                           else {
[17:28:18.092]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.092]                               info, version)
[17:28:18.092]                           }
[17:28:18.092]                           base::stop(msg)
[17:28:18.092]                         }
[17:28:18.092]                       })
[17:28:18.092]                     }
[17:28:18.092]                     ...future.strategy.old <- future::plan("list")
[17:28:18.092]                     options(future.plan = NULL)
[17:28:18.092]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.092]                     future::plan("default", .cleanup = FALSE, 
[17:28:18.092]                       .init = FALSE)
[17:28:18.092]                   }
[17:28:18.092]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:28:18.092]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:28:18.092]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:28:18.092]                 }
[17:28:18.092]                 ...future.workdir <- getwd()
[17:28:18.092]             }
[17:28:18.092]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.092]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.092]         }
[17:28:18.092]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.092]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.092]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.092]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.092]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.092]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.092]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.092]             base::names(...future.oldOptions))
[17:28:18.092]     }
[17:28:18.092]     if (FALSE) {
[17:28:18.092]     }
[17:28:18.092]     else {
[17:28:18.092]         if (TRUE) {
[17:28:18.092]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.092]                 open = "w")
[17:28:18.092]         }
[17:28:18.092]         else {
[17:28:18.092]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.092]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.092]         }
[17:28:18.092]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.092]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.092]             base::sink(type = "output", split = FALSE)
[17:28:18.092]             base::close(...future.stdout)
[17:28:18.092]         }, add = TRUE)
[17:28:18.092]     }
[17:28:18.092]     ...future.frame <- base::sys.nframe()
[17:28:18.092]     ...future.conditions <- base::list()
[17:28:18.092]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.092]     if (FALSE) {
[17:28:18.092]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.092]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.092]     }
[17:28:18.092]     ...future.result <- base::tryCatch({
[17:28:18.092]         base::withCallingHandlers({
[17:28:18.092]             ...future.value <- base::withVisible(base::local({
[17:28:18.092]                 sample(x, size = 1L)
[17:28:18.092]             }))
[17:28:18.092]             future::FutureResult(value = ...future.value$value, 
[17:28:18.092]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.092]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.092]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.092]                     ...future.globalenv.names))
[17:28:18.092]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.092]         }, condition = base::local({
[17:28:18.092]             c <- base::c
[17:28:18.092]             inherits <- base::inherits
[17:28:18.092]             invokeRestart <- base::invokeRestart
[17:28:18.092]             length <- base::length
[17:28:18.092]             list <- base::list
[17:28:18.092]             seq.int <- base::seq.int
[17:28:18.092]             signalCondition <- base::signalCondition
[17:28:18.092]             sys.calls <- base::sys.calls
[17:28:18.092]             `[[` <- base::`[[`
[17:28:18.092]             `+` <- base::`+`
[17:28:18.092]             `<<-` <- base::`<<-`
[17:28:18.092]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.092]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.092]                   3L)]
[17:28:18.092]             }
[17:28:18.092]             function(cond) {
[17:28:18.092]                 is_error <- inherits(cond, "error")
[17:28:18.092]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.092]                   NULL)
[17:28:18.092]                 if (is_error) {
[17:28:18.092]                   sessionInformation <- function() {
[17:28:18.092]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.092]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.092]                       search = base::search(), system = base::Sys.info())
[17:28:18.092]                   }
[17:28:18.092]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.092]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.092]                     cond$call), session = sessionInformation(), 
[17:28:18.092]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.092]                   signalCondition(cond)
[17:28:18.092]                 }
[17:28:18.092]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.092]                 "immediateCondition"))) {
[17:28:18.092]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.092]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.092]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.092]                   if (TRUE && !signal) {
[17:28:18.092]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.092]                     {
[17:28:18.092]                       inherits <- base::inherits
[17:28:18.092]                       invokeRestart <- base::invokeRestart
[17:28:18.092]                       is.null <- base::is.null
[17:28:18.092]                       muffled <- FALSE
[17:28:18.092]                       if (inherits(cond, "message")) {
[17:28:18.092]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.092]                         if (muffled) 
[17:28:18.092]                           invokeRestart("muffleMessage")
[17:28:18.092]                       }
[17:28:18.092]                       else if (inherits(cond, "warning")) {
[17:28:18.092]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.092]                         if (muffled) 
[17:28:18.092]                           invokeRestart("muffleWarning")
[17:28:18.092]                       }
[17:28:18.092]                       else if (inherits(cond, "condition")) {
[17:28:18.092]                         if (!is.null(pattern)) {
[17:28:18.092]                           computeRestarts <- base::computeRestarts
[17:28:18.092]                           grepl <- base::grepl
[17:28:18.092]                           restarts <- computeRestarts(cond)
[17:28:18.092]                           for (restart in restarts) {
[17:28:18.092]                             name <- restart$name
[17:28:18.092]                             if (is.null(name)) 
[17:28:18.092]                               next
[17:28:18.092]                             if (!grepl(pattern, name)) 
[17:28:18.092]                               next
[17:28:18.092]                             invokeRestart(restart)
[17:28:18.092]                             muffled <- TRUE
[17:28:18.092]                             break
[17:28:18.092]                           }
[17:28:18.092]                         }
[17:28:18.092]                       }
[17:28:18.092]                       invisible(muffled)
[17:28:18.092]                     }
[17:28:18.092]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.092]                   }
[17:28:18.092]                 }
[17:28:18.092]                 else {
[17:28:18.092]                   if (TRUE) {
[17:28:18.092]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.092]                     {
[17:28:18.092]                       inherits <- base::inherits
[17:28:18.092]                       invokeRestart <- base::invokeRestart
[17:28:18.092]                       is.null <- base::is.null
[17:28:18.092]                       muffled <- FALSE
[17:28:18.092]                       if (inherits(cond, "message")) {
[17:28:18.092]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.092]                         if (muffled) 
[17:28:18.092]                           invokeRestart("muffleMessage")
[17:28:18.092]                       }
[17:28:18.092]                       else if (inherits(cond, "warning")) {
[17:28:18.092]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.092]                         if (muffled) 
[17:28:18.092]                           invokeRestart("muffleWarning")
[17:28:18.092]                       }
[17:28:18.092]                       else if (inherits(cond, "condition")) {
[17:28:18.092]                         if (!is.null(pattern)) {
[17:28:18.092]                           computeRestarts <- base::computeRestarts
[17:28:18.092]                           grepl <- base::grepl
[17:28:18.092]                           restarts <- computeRestarts(cond)
[17:28:18.092]                           for (restart in restarts) {
[17:28:18.092]                             name <- restart$name
[17:28:18.092]                             if (is.null(name)) 
[17:28:18.092]                               next
[17:28:18.092]                             if (!grepl(pattern, name)) 
[17:28:18.092]                               next
[17:28:18.092]                             invokeRestart(restart)
[17:28:18.092]                             muffled <- TRUE
[17:28:18.092]                             break
[17:28:18.092]                           }
[17:28:18.092]                         }
[17:28:18.092]                       }
[17:28:18.092]                       invisible(muffled)
[17:28:18.092]                     }
[17:28:18.092]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.092]                   }
[17:28:18.092]                 }
[17:28:18.092]             }
[17:28:18.092]         }))
[17:28:18.092]     }, error = function(ex) {
[17:28:18.092]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.092]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.092]                 ...future.rng), started = ...future.startTime, 
[17:28:18.092]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.092]             version = "1.8"), class = "FutureResult")
[17:28:18.092]     }, finally = {
[17:28:18.092]         if (!identical(...future.workdir, getwd())) 
[17:28:18.092]             setwd(...future.workdir)
[17:28:18.092]         {
[17:28:18.092]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.092]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.092]             }
[17:28:18.092]             base::options(...future.oldOptions)
[17:28:18.092]             if (.Platform$OS.type == "windows") {
[17:28:18.092]                 old_names <- names(...future.oldEnvVars)
[17:28:18.092]                 envs <- base::Sys.getenv()
[17:28:18.092]                 names <- names(envs)
[17:28:18.092]                 common <- intersect(names, old_names)
[17:28:18.092]                 added <- setdiff(names, old_names)
[17:28:18.092]                 removed <- setdiff(old_names, names)
[17:28:18.092]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.092]                   envs[common]]
[17:28:18.092]                 NAMES <- toupper(changed)
[17:28:18.092]                 args <- list()
[17:28:18.092]                 for (kk in seq_along(NAMES)) {
[17:28:18.092]                   name <- changed[[kk]]
[17:28:18.092]                   NAME <- NAMES[[kk]]
[17:28:18.092]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.092]                     next
[17:28:18.092]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.092]                 }
[17:28:18.092]                 NAMES <- toupper(added)
[17:28:18.092]                 for (kk in seq_along(NAMES)) {
[17:28:18.092]                   name <- added[[kk]]
[17:28:18.092]                   NAME <- NAMES[[kk]]
[17:28:18.092]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.092]                     next
[17:28:18.092]                   args[[name]] <- ""
[17:28:18.092]                 }
[17:28:18.092]                 NAMES <- toupper(removed)
[17:28:18.092]                 for (kk in seq_along(NAMES)) {
[17:28:18.092]                   name <- removed[[kk]]
[17:28:18.092]                   NAME <- NAMES[[kk]]
[17:28:18.092]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.092]                     next
[17:28:18.092]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.092]                 }
[17:28:18.092]                 if (length(args) > 0) 
[17:28:18.092]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.092]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.092]             }
[17:28:18.092]             else {
[17:28:18.092]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.092]             }
[17:28:18.092]             {
[17:28:18.092]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.092]                   0L) {
[17:28:18.092]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.092]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.092]                   base::options(opts)
[17:28:18.092]                 }
[17:28:18.092]                 {
[17:28:18.092]                   {
[17:28:18.092]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:18.092]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:18.092]                     -1344458670L), envir = base::globalenv(), 
[17:28:18.092]                       inherits = FALSE)
[17:28:18.092]                     NULL
[17:28:18.092]                   }
[17:28:18.092]                   options(future.plan = NULL)
[17:28:18.092]                   if (is.na(NA_character_)) 
[17:28:18.092]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.092]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.092]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.092]                     .init = FALSE)
[17:28:18.092]                 }
[17:28:18.092]             }
[17:28:18.092]         }
[17:28:18.092]     })
[17:28:18.092]     if (TRUE) {
[17:28:18.092]         base::sink(type = "output", split = FALSE)
[17:28:18.092]         if (TRUE) {
[17:28:18.092]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.092]         }
[17:28:18.092]         else {
[17:28:18.092]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.092]         }
[17:28:18.092]         base::close(...future.stdout)
[17:28:18.092]         ...future.stdout <- NULL
[17:28:18.092]     }
[17:28:18.092]     ...future.result$conditions <- ...future.conditions
[17:28:18.092]     ...future.result$finished <- base::Sys.time()
[17:28:18.092]     ...future.result
[17:28:18.092] }
[17:28:18.096] assign_globals() ...
[17:28:18.096] List of 1
[17:28:18.096]  $ x: int [1:4] 0 1 2 3
[17:28:18.096]  - attr(*, "where")=List of 1
[17:28:18.096]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.096]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.096]  - attr(*, "resolved")= logi FALSE
[17:28:18.096]  - attr(*, "total_size")= num 64
[17:28:18.096]  - attr(*, "already-done")= logi TRUE
[17:28:18.099] - copied 'x' to environment
[17:28:18.099] assign_globals() ... done
[17:28:18.100] plan(): Setting new future strategy stack:
[17:28:18.100] List of future strategies:
[17:28:18.100] 1. sequential:
[17:28:18.100]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.100]    - tweaked: FALSE
[17:28:18.100]    - call: NULL
[17:28:18.101] plan(): nbrOfWorkers() = 1
[17:28:18.102] plan(): Setting new future strategy stack:
[17:28:18.102] List of future strategies:
[17:28:18.102] 1. sequential:
[17:28:18.102]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.102]    - tweaked: FALSE
[17:28:18.102]    - call: plan(strategy)
[17:28:18.103] plan(): nbrOfWorkers() = 1
[17:28:18.104] SequentialFuture started (and completed)
[17:28:18.104] - Launch lazy future ... done
[17:28:18.104] run() for 'SequentialFuture' ... done
[17:28:18.105] getGlobalsAndPackages() ...
[17:28:18.105] Searching for globals...
[17:28:18.106] - globals found: [3] '{', 'sample', 'x'
[17:28:18.106] Searching for globals ... DONE
[17:28:18.106] Resolving globals: FALSE
[17:28:18.107] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.107] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.107] - globals: [1] 'x'
[17:28:18.107] 
[17:28:18.108] getGlobalsAndPackages() ... DONE
[17:28:18.108] run() for 'Future' ...
[17:28:18.108] - state: 'created'
[17:28:18.108] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.109] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.109] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.109]   - Field: 'label'
[17:28:18.109]   - Field: 'local'
[17:28:18.109]   - Field: 'owner'
[17:28:18.110]   - Field: 'envir'
[17:28:18.110]   - Field: 'packages'
[17:28:18.110]   - Field: 'gc'
[17:28:18.110]   - Field: 'conditions'
[17:28:18.110]   - Field: 'expr'
[17:28:18.110]   - Field: 'uuid'
[17:28:18.111]   - Field: 'seed'
[17:28:18.111]   - Field: 'version'
[17:28:18.111]   - Field: 'result'
[17:28:18.111]   - Field: 'asynchronous'
[17:28:18.111]   - Field: 'calls'
[17:28:18.111]   - Field: 'globals'
[17:28:18.112]   - Field: 'stdout'
[17:28:18.112]   - Field: 'earlySignal'
[17:28:18.112]   - Field: 'lazy'
[17:28:18.112]   - Field: 'state'
[17:28:18.112] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.112] - Launch lazy future ...
[17:28:18.113] Packages needed by the future expression (n = 0): <none>
[17:28:18.113] Packages needed by future strategies (n = 0): <none>
[17:28:18.113] {
[17:28:18.113]     {
[17:28:18.113]         {
[17:28:18.113]             ...future.startTime <- base::Sys.time()
[17:28:18.113]             {
[17:28:18.113]                 {
[17:28:18.113]                   {
[17:28:18.113]                     {
[17:28:18.113]                       base::local({
[17:28:18.113]                         has_future <- base::requireNamespace("future", 
[17:28:18.113]                           quietly = TRUE)
[17:28:18.113]                         if (has_future) {
[17:28:18.113]                           ns <- base::getNamespace("future")
[17:28:18.113]                           version <- ns[[".package"]][["version"]]
[17:28:18.113]                           if (is.null(version)) 
[17:28:18.113]                             version <- utils::packageVersion("future")
[17:28:18.113]                         }
[17:28:18.113]                         else {
[17:28:18.113]                           version <- NULL
[17:28:18.113]                         }
[17:28:18.113]                         if (!has_future || version < "1.8.0") {
[17:28:18.113]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.113]                             "", base::R.version$version.string), 
[17:28:18.113]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:18.113]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.113]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.113]                               "release", "version")], collapse = " "), 
[17:28:18.113]                             hostname = base::Sys.info()[["nodename"]])
[17:28:18.113]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.113]                             info)
[17:28:18.113]                           info <- base::paste(info, collapse = "; ")
[17:28:18.113]                           if (!has_future) {
[17:28:18.113]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.113]                               info)
[17:28:18.113]                           }
[17:28:18.113]                           else {
[17:28:18.113]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.113]                               info, version)
[17:28:18.113]                           }
[17:28:18.113]                           base::stop(msg)
[17:28:18.113]                         }
[17:28:18.113]                       })
[17:28:18.113]                     }
[17:28:18.113]                     ...future.strategy.old <- future::plan("list")
[17:28:18.113]                     options(future.plan = NULL)
[17:28:18.113]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.113]                     future::plan("default", .cleanup = FALSE, 
[17:28:18.113]                       .init = FALSE)
[17:28:18.113]                   }
[17:28:18.113]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:28:18.113]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:28:18.113]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:28:18.113]                 }
[17:28:18.113]                 ...future.workdir <- getwd()
[17:28:18.113]             }
[17:28:18.113]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.113]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.113]         }
[17:28:18.113]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.113]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.113]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.113]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.113]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.113]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.113]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.113]             base::names(...future.oldOptions))
[17:28:18.113]     }
[17:28:18.113]     if (FALSE) {
[17:28:18.113]     }
[17:28:18.113]     else {
[17:28:18.113]         if (TRUE) {
[17:28:18.113]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.113]                 open = "w")
[17:28:18.113]         }
[17:28:18.113]         else {
[17:28:18.113]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.113]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.113]         }
[17:28:18.113]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.113]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.113]             base::sink(type = "output", split = FALSE)
[17:28:18.113]             base::close(...future.stdout)
[17:28:18.113]         }, add = TRUE)
[17:28:18.113]     }
[17:28:18.113]     ...future.frame <- base::sys.nframe()
[17:28:18.113]     ...future.conditions <- base::list()
[17:28:18.113]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.113]     if (FALSE) {
[17:28:18.113]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.113]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.113]     }
[17:28:18.113]     ...future.result <- base::tryCatch({
[17:28:18.113]         base::withCallingHandlers({
[17:28:18.113]             ...future.value <- base::withVisible(base::local({
[17:28:18.113]                 sample(x, size = 1L)
[17:28:18.113]             }))
[17:28:18.113]             future::FutureResult(value = ...future.value$value, 
[17:28:18.113]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.113]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.113]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.113]                     ...future.globalenv.names))
[17:28:18.113]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.113]         }, condition = base::local({
[17:28:18.113]             c <- base::c
[17:28:18.113]             inherits <- base::inherits
[17:28:18.113]             invokeRestart <- base::invokeRestart
[17:28:18.113]             length <- base::length
[17:28:18.113]             list <- base::list
[17:28:18.113]             seq.int <- base::seq.int
[17:28:18.113]             signalCondition <- base::signalCondition
[17:28:18.113]             sys.calls <- base::sys.calls
[17:28:18.113]             `[[` <- base::`[[`
[17:28:18.113]             `+` <- base::`+`
[17:28:18.113]             `<<-` <- base::`<<-`
[17:28:18.113]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.113]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.113]                   3L)]
[17:28:18.113]             }
[17:28:18.113]             function(cond) {
[17:28:18.113]                 is_error <- inherits(cond, "error")
[17:28:18.113]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.113]                   NULL)
[17:28:18.113]                 if (is_error) {
[17:28:18.113]                   sessionInformation <- function() {
[17:28:18.113]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.113]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.113]                       search = base::search(), system = base::Sys.info())
[17:28:18.113]                   }
[17:28:18.113]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.113]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.113]                     cond$call), session = sessionInformation(), 
[17:28:18.113]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.113]                   signalCondition(cond)
[17:28:18.113]                 }
[17:28:18.113]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.113]                 "immediateCondition"))) {
[17:28:18.113]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.113]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.113]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.113]                   if (TRUE && !signal) {
[17:28:18.113]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.113]                     {
[17:28:18.113]                       inherits <- base::inherits
[17:28:18.113]                       invokeRestart <- base::invokeRestart
[17:28:18.113]                       is.null <- base::is.null
[17:28:18.113]                       muffled <- FALSE
[17:28:18.113]                       if (inherits(cond, "message")) {
[17:28:18.113]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.113]                         if (muffled) 
[17:28:18.113]                           invokeRestart("muffleMessage")
[17:28:18.113]                       }
[17:28:18.113]                       else if (inherits(cond, "warning")) {
[17:28:18.113]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.113]                         if (muffled) 
[17:28:18.113]                           invokeRestart("muffleWarning")
[17:28:18.113]                       }
[17:28:18.113]                       else if (inherits(cond, "condition")) {
[17:28:18.113]                         if (!is.null(pattern)) {
[17:28:18.113]                           computeRestarts <- base::computeRestarts
[17:28:18.113]                           grepl <- base::grepl
[17:28:18.113]                           restarts <- computeRestarts(cond)
[17:28:18.113]                           for (restart in restarts) {
[17:28:18.113]                             name <- restart$name
[17:28:18.113]                             if (is.null(name)) 
[17:28:18.113]                               next
[17:28:18.113]                             if (!grepl(pattern, name)) 
[17:28:18.113]                               next
[17:28:18.113]                             invokeRestart(restart)
[17:28:18.113]                             muffled <- TRUE
[17:28:18.113]                             break
[17:28:18.113]                           }
[17:28:18.113]                         }
[17:28:18.113]                       }
[17:28:18.113]                       invisible(muffled)
[17:28:18.113]                     }
[17:28:18.113]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.113]                   }
[17:28:18.113]                 }
[17:28:18.113]                 else {
[17:28:18.113]                   if (TRUE) {
[17:28:18.113]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.113]                     {
[17:28:18.113]                       inherits <- base::inherits
[17:28:18.113]                       invokeRestart <- base::invokeRestart
[17:28:18.113]                       is.null <- base::is.null
[17:28:18.113]                       muffled <- FALSE
[17:28:18.113]                       if (inherits(cond, "message")) {
[17:28:18.113]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.113]                         if (muffled) 
[17:28:18.113]                           invokeRestart("muffleMessage")
[17:28:18.113]                       }
[17:28:18.113]                       else if (inherits(cond, "warning")) {
[17:28:18.113]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.113]                         if (muffled) 
[17:28:18.113]                           invokeRestart("muffleWarning")
[17:28:18.113]                       }
[17:28:18.113]                       else if (inherits(cond, "condition")) {
[17:28:18.113]                         if (!is.null(pattern)) {
[17:28:18.113]                           computeRestarts <- base::computeRestarts
[17:28:18.113]                           grepl <- base::grepl
[17:28:18.113]                           restarts <- computeRestarts(cond)
[17:28:18.113]                           for (restart in restarts) {
[17:28:18.113]                             name <- restart$name
[17:28:18.113]                             if (is.null(name)) 
[17:28:18.113]                               next
[17:28:18.113]                             if (!grepl(pattern, name)) 
[17:28:18.113]                               next
[17:28:18.113]                             invokeRestart(restart)
[17:28:18.113]                             muffled <- TRUE
[17:28:18.113]                             break
[17:28:18.113]                           }
[17:28:18.113]                         }
[17:28:18.113]                       }
[17:28:18.113]                       invisible(muffled)
[17:28:18.113]                     }
[17:28:18.113]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.113]                   }
[17:28:18.113]                 }
[17:28:18.113]             }
[17:28:18.113]         }))
[17:28:18.113]     }, error = function(ex) {
[17:28:18.113]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.113]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.113]                 ...future.rng), started = ...future.startTime, 
[17:28:18.113]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.113]             version = "1.8"), class = "FutureResult")
[17:28:18.113]     }, finally = {
[17:28:18.113]         if (!identical(...future.workdir, getwd())) 
[17:28:18.113]             setwd(...future.workdir)
[17:28:18.113]         {
[17:28:18.113]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.113]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.113]             }
[17:28:18.113]             base::options(...future.oldOptions)
[17:28:18.113]             if (.Platform$OS.type == "windows") {
[17:28:18.113]                 old_names <- names(...future.oldEnvVars)
[17:28:18.113]                 envs <- base::Sys.getenv()
[17:28:18.113]                 names <- names(envs)
[17:28:18.113]                 common <- intersect(names, old_names)
[17:28:18.113]                 added <- setdiff(names, old_names)
[17:28:18.113]                 removed <- setdiff(old_names, names)
[17:28:18.113]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.113]                   envs[common]]
[17:28:18.113]                 NAMES <- toupper(changed)
[17:28:18.113]                 args <- list()
[17:28:18.113]                 for (kk in seq_along(NAMES)) {
[17:28:18.113]                   name <- changed[[kk]]
[17:28:18.113]                   NAME <- NAMES[[kk]]
[17:28:18.113]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.113]                     next
[17:28:18.113]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.113]                 }
[17:28:18.113]                 NAMES <- toupper(added)
[17:28:18.113]                 for (kk in seq_along(NAMES)) {
[17:28:18.113]                   name <- added[[kk]]
[17:28:18.113]                   NAME <- NAMES[[kk]]
[17:28:18.113]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.113]                     next
[17:28:18.113]                   args[[name]] <- ""
[17:28:18.113]                 }
[17:28:18.113]                 NAMES <- toupper(removed)
[17:28:18.113]                 for (kk in seq_along(NAMES)) {
[17:28:18.113]                   name <- removed[[kk]]
[17:28:18.113]                   NAME <- NAMES[[kk]]
[17:28:18.113]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.113]                     next
[17:28:18.113]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.113]                 }
[17:28:18.113]                 if (length(args) > 0) 
[17:28:18.113]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.113]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.113]             }
[17:28:18.113]             else {
[17:28:18.113]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.113]             }
[17:28:18.113]             {
[17:28:18.113]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.113]                   0L) {
[17:28:18.113]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.113]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.113]                   base::options(opts)
[17:28:18.113]                 }
[17:28:18.113]                 {
[17:28:18.113]                   {
[17:28:18.113]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:28:18.113]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:28:18.113]                     -1344458670L), envir = base::globalenv(), 
[17:28:18.113]                       inherits = FALSE)
[17:28:18.113]                     NULL
[17:28:18.113]                   }
[17:28:18.113]                   options(future.plan = NULL)
[17:28:18.113]                   if (is.na(NA_character_)) 
[17:28:18.113]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.113]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.113]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.113]                     .init = FALSE)
[17:28:18.113]                 }
[17:28:18.113]             }
[17:28:18.113]         }
[17:28:18.113]     })
[17:28:18.113]     if (TRUE) {
[17:28:18.113]         base::sink(type = "output", split = FALSE)
[17:28:18.113]         if (TRUE) {
[17:28:18.113]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.113]         }
[17:28:18.113]         else {
[17:28:18.113]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.113]         }
[17:28:18.113]         base::close(...future.stdout)
[17:28:18.113]         ...future.stdout <- NULL
[17:28:18.113]     }
[17:28:18.113]     ...future.result$conditions <- ...future.conditions
[17:28:18.113]     ...future.result$finished <- base::Sys.time()
[17:28:18.113]     ...future.result
[17:28:18.113] }
[17:28:18.117] assign_globals() ...
[17:28:18.117] List of 1
[17:28:18.117]  $ x: int [1:4] 0 1 2 3
[17:28:18.117]  - attr(*, "where")=List of 1
[17:28:18.117]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.117]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.117]  - attr(*, "resolved")= logi FALSE
[17:28:18.117]  - attr(*, "total_size")= num 64
[17:28:18.117]  - attr(*, "already-done")= logi TRUE
[17:28:18.120] - copied 'x' to environment
[17:28:18.120] assign_globals() ... done
[17:28:18.121] plan(): Setting new future strategy stack:
[17:28:18.121] List of future strategies:
[17:28:18.121] 1. sequential:
[17:28:18.121]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.121]    - tweaked: FALSE
[17:28:18.121]    - call: NULL
[17:28:18.121] plan(): nbrOfWorkers() = 1
[17:28:18.123] plan(): Setting new future strategy stack:
[17:28:18.123] List of future strategies:
[17:28:18.123] 1. sequential:
[17:28:18.123]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.123]    - tweaked: FALSE
[17:28:18.123]    - call: plan(strategy)
[17:28:18.123] plan(): nbrOfWorkers() = 1
[17:28:18.124] SequentialFuture started (and completed)
[17:28:18.124] - Launch lazy future ... done
[17:28:18.124] run() for 'SequentialFuture' ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[17:28:18.125] getGlobalsAndPackages() ...
[17:28:18.126] Searching for globals...
[17:28:18.127] - globals found: [3] '{', 'sample', 'x'
[17:28:18.127] Searching for globals ... DONE
[17:28:18.127] Resolving globals: FALSE
[17:28:18.127] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.128] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.128] - globals: [1] 'x'
[17:28:18.128] 
[17:28:18.128] getGlobalsAndPackages() ... DONE
[17:28:18.129] run() for 'Future' ...
[17:28:18.129] - state: 'created'
[17:28:18.129] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.129] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.130] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.130]   - Field: 'label'
[17:28:18.130]   - Field: 'local'
[17:28:18.130]   - Field: 'owner'
[17:28:18.130]   - Field: 'envir'
[17:28:18.131]   - Field: 'packages'
[17:28:18.131]   - Field: 'gc'
[17:28:18.131]   - Field: 'conditions'
[17:28:18.131]   - Field: 'expr'
[17:28:18.131]   - Field: 'uuid'
[17:28:18.131]   - Field: 'seed'
[17:28:18.133]   - Field: 'version'
[17:28:18.133]   - Field: 'result'
[17:28:18.133]   - Field: 'asynchronous'
[17:28:18.133]   - Field: 'calls'
[17:28:18.133]   - Field: 'globals'
[17:28:18.133]   - Field: 'stdout'
[17:28:18.134]   - Field: 'earlySignal'
[17:28:18.134]   - Field: 'lazy'
[17:28:18.134]   - Field: 'state'
[17:28:18.134] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.134] - Launch lazy future ...
[17:28:18.135] Packages needed by the future expression (n = 0): <none>
[17:28:18.135] Packages needed by future strategies (n = 0): <none>
[17:28:18.135] {
[17:28:18.135]     {
[17:28:18.135]         {
[17:28:18.135]             ...future.startTime <- base::Sys.time()
[17:28:18.135]             {
[17:28:18.135]                 {
[17:28:18.135]                   {
[17:28:18.135]                     base::local({
[17:28:18.135]                       has_future <- base::requireNamespace("future", 
[17:28:18.135]                         quietly = TRUE)
[17:28:18.135]                       if (has_future) {
[17:28:18.135]                         ns <- base::getNamespace("future")
[17:28:18.135]                         version <- ns[[".package"]][["version"]]
[17:28:18.135]                         if (is.null(version)) 
[17:28:18.135]                           version <- utils::packageVersion("future")
[17:28:18.135]                       }
[17:28:18.135]                       else {
[17:28:18.135]                         version <- NULL
[17:28:18.135]                       }
[17:28:18.135]                       if (!has_future || version < "1.8.0") {
[17:28:18.135]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.135]                           "", base::R.version$version.string), 
[17:28:18.135]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.135]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.135]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.135]                             "release", "version")], collapse = " "), 
[17:28:18.135]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.135]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.135]                           info)
[17:28:18.135]                         info <- base::paste(info, collapse = "; ")
[17:28:18.135]                         if (!has_future) {
[17:28:18.135]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.135]                             info)
[17:28:18.135]                         }
[17:28:18.135]                         else {
[17:28:18.135]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.135]                             info, version)
[17:28:18.135]                         }
[17:28:18.135]                         base::stop(msg)
[17:28:18.135]                       }
[17:28:18.135]                     })
[17:28:18.135]                   }
[17:28:18.135]                   ...future.strategy.old <- future::plan("list")
[17:28:18.135]                   options(future.plan = NULL)
[17:28:18.135]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.135]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.135]                 }
[17:28:18.135]                 ...future.workdir <- getwd()
[17:28:18.135]             }
[17:28:18.135]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.135]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.135]         }
[17:28:18.135]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.135]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.135]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.135]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.135]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.135]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.135]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.135]             base::names(...future.oldOptions))
[17:28:18.135]     }
[17:28:18.135]     if (FALSE) {
[17:28:18.135]     }
[17:28:18.135]     else {
[17:28:18.135]         if (TRUE) {
[17:28:18.135]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.135]                 open = "w")
[17:28:18.135]         }
[17:28:18.135]         else {
[17:28:18.135]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.135]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.135]         }
[17:28:18.135]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.135]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.135]             base::sink(type = "output", split = FALSE)
[17:28:18.135]             base::close(...future.stdout)
[17:28:18.135]         }, add = TRUE)
[17:28:18.135]     }
[17:28:18.135]     ...future.frame <- base::sys.nframe()
[17:28:18.135]     ...future.conditions <- base::list()
[17:28:18.135]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.135]     if (FALSE) {
[17:28:18.135]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.135]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.135]     }
[17:28:18.135]     ...future.result <- base::tryCatch({
[17:28:18.135]         base::withCallingHandlers({
[17:28:18.135]             ...future.value <- base::withVisible(base::local({
[17:28:18.135]                 sample(x, size = 1L)
[17:28:18.135]             }))
[17:28:18.135]             future::FutureResult(value = ...future.value$value, 
[17:28:18.135]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.135]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.135]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.135]                     ...future.globalenv.names))
[17:28:18.135]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.135]         }, condition = base::local({
[17:28:18.135]             c <- base::c
[17:28:18.135]             inherits <- base::inherits
[17:28:18.135]             invokeRestart <- base::invokeRestart
[17:28:18.135]             length <- base::length
[17:28:18.135]             list <- base::list
[17:28:18.135]             seq.int <- base::seq.int
[17:28:18.135]             signalCondition <- base::signalCondition
[17:28:18.135]             sys.calls <- base::sys.calls
[17:28:18.135]             `[[` <- base::`[[`
[17:28:18.135]             `+` <- base::`+`
[17:28:18.135]             `<<-` <- base::`<<-`
[17:28:18.135]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.135]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.135]                   3L)]
[17:28:18.135]             }
[17:28:18.135]             function(cond) {
[17:28:18.135]                 is_error <- inherits(cond, "error")
[17:28:18.135]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.135]                   NULL)
[17:28:18.135]                 if (is_error) {
[17:28:18.135]                   sessionInformation <- function() {
[17:28:18.135]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.135]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.135]                       search = base::search(), system = base::Sys.info())
[17:28:18.135]                   }
[17:28:18.135]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.135]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.135]                     cond$call), session = sessionInformation(), 
[17:28:18.135]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.135]                   signalCondition(cond)
[17:28:18.135]                 }
[17:28:18.135]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.135]                 "immediateCondition"))) {
[17:28:18.135]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.135]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.135]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.135]                   if (TRUE && !signal) {
[17:28:18.135]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.135]                     {
[17:28:18.135]                       inherits <- base::inherits
[17:28:18.135]                       invokeRestart <- base::invokeRestart
[17:28:18.135]                       is.null <- base::is.null
[17:28:18.135]                       muffled <- FALSE
[17:28:18.135]                       if (inherits(cond, "message")) {
[17:28:18.135]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.135]                         if (muffled) 
[17:28:18.135]                           invokeRestart("muffleMessage")
[17:28:18.135]                       }
[17:28:18.135]                       else if (inherits(cond, "warning")) {
[17:28:18.135]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.135]                         if (muffled) 
[17:28:18.135]                           invokeRestart("muffleWarning")
[17:28:18.135]                       }
[17:28:18.135]                       else if (inherits(cond, "condition")) {
[17:28:18.135]                         if (!is.null(pattern)) {
[17:28:18.135]                           computeRestarts <- base::computeRestarts
[17:28:18.135]                           grepl <- base::grepl
[17:28:18.135]                           restarts <- computeRestarts(cond)
[17:28:18.135]                           for (restart in restarts) {
[17:28:18.135]                             name <- restart$name
[17:28:18.135]                             if (is.null(name)) 
[17:28:18.135]                               next
[17:28:18.135]                             if (!grepl(pattern, name)) 
[17:28:18.135]                               next
[17:28:18.135]                             invokeRestart(restart)
[17:28:18.135]                             muffled <- TRUE
[17:28:18.135]                             break
[17:28:18.135]                           }
[17:28:18.135]                         }
[17:28:18.135]                       }
[17:28:18.135]                       invisible(muffled)
[17:28:18.135]                     }
[17:28:18.135]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.135]                   }
[17:28:18.135]                 }
[17:28:18.135]                 else {
[17:28:18.135]                   if (TRUE) {
[17:28:18.135]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.135]                     {
[17:28:18.135]                       inherits <- base::inherits
[17:28:18.135]                       invokeRestart <- base::invokeRestart
[17:28:18.135]                       is.null <- base::is.null
[17:28:18.135]                       muffled <- FALSE
[17:28:18.135]                       if (inherits(cond, "message")) {
[17:28:18.135]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.135]                         if (muffled) 
[17:28:18.135]                           invokeRestart("muffleMessage")
[17:28:18.135]                       }
[17:28:18.135]                       else if (inherits(cond, "warning")) {
[17:28:18.135]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.135]                         if (muffled) 
[17:28:18.135]                           invokeRestart("muffleWarning")
[17:28:18.135]                       }
[17:28:18.135]                       else if (inherits(cond, "condition")) {
[17:28:18.135]                         if (!is.null(pattern)) {
[17:28:18.135]                           computeRestarts <- base::computeRestarts
[17:28:18.135]                           grepl <- base::grepl
[17:28:18.135]                           restarts <- computeRestarts(cond)
[17:28:18.135]                           for (restart in restarts) {
[17:28:18.135]                             name <- restart$name
[17:28:18.135]                             if (is.null(name)) 
[17:28:18.135]                               next
[17:28:18.135]                             if (!grepl(pattern, name)) 
[17:28:18.135]                               next
[17:28:18.135]                             invokeRestart(restart)
[17:28:18.135]                             muffled <- TRUE
[17:28:18.135]                             break
[17:28:18.135]                           }
[17:28:18.135]                         }
[17:28:18.135]                       }
[17:28:18.135]                       invisible(muffled)
[17:28:18.135]                     }
[17:28:18.135]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.135]                   }
[17:28:18.135]                 }
[17:28:18.135]             }
[17:28:18.135]         }))
[17:28:18.135]     }, error = function(ex) {
[17:28:18.135]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.135]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.135]                 ...future.rng), started = ...future.startTime, 
[17:28:18.135]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.135]             version = "1.8"), class = "FutureResult")
[17:28:18.135]     }, finally = {
[17:28:18.135]         if (!identical(...future.workdir, getwd())) 
[17:28:18.135]             setwd(...future.workdir)
[17:28:18.135]         {
[17:28:18.135]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.135]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.135]             }
[17:28:18.135]             base::options(...future.oldOptions)
[17:28:18.135]             if (.Platform$OS.type == "windows") {
[17:28:18.135]                 old_names <- names(...future.oldEnvVars)
[17:28:18.135]                 envs <- base::Sys.getenv()
[17:28:18.135]                 names <- names(envs)
[17:28:18.135]                 common <- intersect(names, old_names)
[17:28:18.135]                 added <- setdiff(names, old_names)
[17:28:18.135]                 removed <- setdiff(old_names, names)
[17:28:18.135]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.135]                   envs[common]]
[17:28:18.135]                 NAMES <- toupper(changed)
[17:28:18.135]                 args <- list()
[17:28:18.135]                 for (kk in seq_along(NAMES)) {
[17:28:18.135]                   name <- changed[[kk]]
[17:28:18.135]                   NAME <- NAMES[[kk]]
[17:28:18.135]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.135]                     next
[17:28:18.135]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.135]                 }
[17:28:18.135]                 NAMES <- toupper(added)
[17:28:18.135]                 for (kk in seq_along(NAMES)) {
[17:28:18.135]                   name <- added[[kk]]
[17:28:18.135]                   NAME <- NAMES[[kk]]
[17:28:18.135]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.135]                     next
[17:28:18.135]                   args[[name]] <- ""
[17:28:18.135]                 }
[17:28:18.135]                 NAMES <- toupper(removed)
[17:28:18.135]                 for (kk in seq_along(NAMES)) {
[17:28:18.135]                   name <- removed[[kk]]
[17:28:18.135]                   NAME <- NAMES[[kk]]
[17:28:18.135]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.135]                     next
[17:28:18.135]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.135]                 }
[17:28:18.135]                 if (length(args) > 0) 
[17:28:18.135]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.135]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.135]             }
[17:28:18.135]             else {
[17:28:18.135]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.135]             }
[17:28:18.135]             {
[17:28:18.135]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.135]                   0L) {
[17:28:18.135]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.135]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.135]                   base::options(opts)
[17:28:18.135]                 }
[17:28:18.135]                 {
[17:28:18.135]                   {
[17:28:18.135]                     base::assign(".Random.seed", c(10407L, 1229781135L, 
[17:28:18.135]                     -1383414008L, -272798089L, 1000427506L, 167001878L, 
[17:28:18.135]                     -1555199413L), envir = base::globalenv(), 
[17:28:18.135]                       inherits = FALSE)
[17:28:18.135]                     NULL
[17:28:18.135]                   }
[17:28:18.135]                   options(future.plan = NULL)
[17:28:18.135]                   if (is.na(NA_character_)) 
[17:28:18.135]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.135]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.135]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.135]                     .init = FALSE)
[17:28:18.135]                 }
[17:28:18.135]             }
[17:28:18.135]         }
[17:28:18.135]     })
[17:28:18.135]     if (TRUE) {
[17:28:18.135]         base::sink(type = "output", split = FALSE)
[17:28:18.135]         if (TRUE) {
[17:28:18.135]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.135]         }
[17:28:18.135]         else {
[17:28:18.135]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.135]         }
[17:28:18.135]         base::close(...future.stdout)
[17:28:18.135]         ...future.stdout <- NULL
[17:28:18.135]     }
[17:28:18.135]     ...future.result$conditions <- ...future.conditions
[17:28:18.135]     ...future.result$finished <- base::Sys.time()
[17:28:18.135]     ...future.result
[17:28:18.135] }
[17:28:18.139] assign_globals() ...
[17:28:18.139] List of 1
[17:28:18.139]  $ x: int [1:4] 0 1 2 3
[17:28:18.139]  - attr(*, "where")=List of 1
[17:28:18.139]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.139]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.139]  - attr(*, "resolved")= logi FALSE
[17:28:18.139]  - attr(*, "total_size")= num 64
[17:28:18.139]  - attr(*, "already-done")= logi TRUE
[17:28:18.142] - copied 'x' to environment
[17:28:18.142] assign_globals() ... done
[17:28:18.143] plan(): Setting new future strategy stack:
[17:28:18.143] List of future strategies:
[17:28:18.143] 1. sequential:
[17:28:18.143]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.143]    - tweaked: FALSE
[17:28:18.143]    - call: NULL
[17:28:18.143] plan(): nbrOfWorkers() = 1
[17:28:18.145] plan(): Setting new future strategy stack:
[17:28:18.145] List of future strategies:
[17:28:18.145] 1. sequential:
[17:28:18.145]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.145]    - tweaked: FALSE
[17:28:18.145]    - call: plan(strategy)
[17:28:18.145] plan(): nbrOfWorkers() = 1
[17:28:18.146] SequentialFuture started (and completed)
[17:28:18.146] - Launch lazy future ... done
[17:28:18.146] run() for 'SequentialFuture' ... done
[17:28:18.146] getGlobalsAndPackages() ...
[17:28:18.147] Searching for globals...
[17:28:18.148] - globals found: [3] '{', 'sample', 'x'
[17:28:18.148] Searching for globals ... DONE
[17:28:18.148] Resolving globals: FALSE
[17:28:18.149] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.149] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.149] - globals: [1] 'x'
[17:28:18.149] 
[17:28:18.150] getGlobalsAndPackages() ... DONE
[17:28:18.150] run() for 'Future' ...
[17:28:18.150] - state: 'created'
[17:28:18.150] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.151] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.151] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.151]   - Field: 'label'
[17:28:18.151]   - Field: 'local'
[17:28:18.151]   - Field: 'owner'
[17:28:18.152]   - Field: 'envir'
[17:28:18.152]   - Field: 'packages'
[17:28:18.152]   - Field: 'gc'
[17:28:18.152]   - Field: 'conditions'
[17:28:18.152]   - Field: 'expr'
[17:28:18.152]   - Field: 'uuid'
[17:28:18.153]   - Field: 'seed'
[17:28:18.153]   - Field: 'version'
[17:28:18.153]   - Field: 'result'
[17:28:18.153]   - Field: 'asynchronous'
[17:28:18.153]   - Field: 'calls'
[17:28:18.153]   - Field: 'globals'
[17:28:18.154]   - Field: 'stdout'
[17:28:18.154]   - Field: 'earlySignal'
[17:28:18.154]   - Field: 'lazy'
[17:28:18.154]   - Field: 'state'
[17:28:18.154] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.154] - Launch lazy future ...
[17:28:18.155] Packages needed by the future expression (n = 0): <none>
[17:28:18.155] Packages needed by future strategies (n = 0): <none>
[17:28:18.155] {
[17:28:18.155]     {
[17:28:18.155]         {
[17:28:18.155]             ...future.startTime <- base::Sys.time()
[17:28:18.155]             {
[17:28:18.155]                 {
[17:28:18.155]                   {
[17:28:18.155]                     base::local({
[17:28:18.155]                       has_future <- base::requireNamespace("future", 
[17:28:18.155]                         quietly = TRUE)
[17:28:18.155]                       if (has_future) {
[17:28:18.155]                         ns <- base::getNamespace("future")
[17:28:18.155]                         version <- ns[[".package"]][["version"]]
[17:28:18.155]                         if (is.null(version)) 
[17:28:18.155]                           version <- utils::packageVersion("future")
[17:28:18.155]                       }
[17:28:18.155]                       else {
[17:28:18.155]                         version <- NULL
[17:28:18.155]                       }
[17:28:18.155]                       if (!has_future || version < "1.8.0") {
[17:28:18.155]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.155]                           "", base::R.version$version.string), 
[17:28:18.155]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.155]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.155]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.155]                             "release", "version")], collapse = " "), 
[17:28:18.155]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.155]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.155]                           info)
[17:28:18.155]                         info <- base::paste(info, collapse = "; ")
[17:28:18.155]                         if (!has_future) {
[17:28:18.155]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.155]                             info)
[17:28:18.155]                         }
[17:28:18.155]                         else {
[17:28:18.155]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.155]                             info, version)
[17:28:18.155]                         }
[17:28:18.155]                         base::stop(msg)
[17:28:18.155]                       }
[17:28:18.155]                     })
[17:28:18.155]                   }
[17:28:18.155]                   ...future.strategy.old <- future::plan("list")
[17:28:18.155]                   options(future.plan = NULL)
[17:28:18.155]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.155]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.155]                 }
[17:28:18.155]                 ...future.workdir <- getwd()
[17:28:18.155]             }
[17:28:18.155]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.155]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.155]         }
[17:28:18.155]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.155]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.155]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.155]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.155]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.155]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.155]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.155]             base::names(...future.oldOptions))
[17:28:18.155]     }
[17:28:18.155]     if (FALSE) {
[17:28:18.155]     }
[17:28:18.155]     else {
[17:28:18.155]         if (TRUE) {
[17:28:18.155]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.155]                 open = "w")
[17:28:18.155]         }
[17:28:18.155]         else {
[17:28:18.155]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.155]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.155]         }
[17:28:18.155]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.155]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.155]             base::sink(type = "output", split = FALSE)
[17:28:18.155]             base::close(...future.stdout)
[17:28:18.155]         }, add = TRUE)
[17:28:18.155]     }
[17:28:18.155]     ...future.frame <- base::sys.nframe()
[17:28:18.155]     ...future.conditions <- base::list()
[17:28:18.155]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.155]     if (FALSE) {
[17:28:18.155]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.155]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.155]     }
[17:28:18.155]     ...future.result <- base::tryCatch({
[17:28:18.155]         base::withCallingHandlers({
[17:28:18.155]             ...future.value <- base::withVisible(base::local({
[17:28:18.155]                 sample(x, size = 1L)
[17:28:18.155]             }))
[17:28:18.155]             future::FutureResult(value = ...future.value$value, 
[17:28:18.155]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.155]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.155]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.155]                     ...future.globalenv.names))
[17:28:18.155]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.155]         }, condition = base::local({
[17:28:18.155]             c <- base::c
[17:28:18.155]             inherits <- base::inherits
[17:28:18.155]             invokeRestart <- base::invokeRestart
[17:28:18.155]             length <- base::length
[17:28:18.155]             list <- base::list
[17:28:18.155]             seq.int <- base::seq.int
[17:28:18.155]             signalCondition <- base::signalCondition
[17:28:18.155]             sys.calls <- base::sys.calls
[17:28:18.155]             `[[` <- base::`[[`
[17:28:18.155]             `+` <- base::`+`
[17:28:18.155]             `<<-` <- base::`<<-`
[17:28:18.155]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.155]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.155]                   3L)]
[17:28:18.155]             }
[17:28:18.155]             function(cond) {
[17:28:18.155]                 is_error <- inherits(cond, "error")
[17:28:18.155]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.155]                   NULL)
[17:28:18.155]                 if (is_error) {
[17:28:18.155]                   sessionInformation <- function() {
[17:28:18.155]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.155]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.155]                       search = base::search(), system = base::Sys.info())
[17:28:18.155]                   }
[17:28:18.155]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.155]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.155]                     cond$call), session = sessionInformation(), 
[17:28:18.155]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.155]                   signalCondition(cond)
[17:28:18.155]                 }
[17:28:18.155]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.155]                 "immediateCondition"))) {
[17:28:18.155]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.155]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.155]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.155]                   if (TRUE && !signal) {
[17:28:18.155]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.155]                     {
[17:28:18.155]                       inherits <- base::inherits
[17:28:18.155]                       invokeRestart <- base::invokeRestart
[17:28:18.155]                       is.null <- base::is.null
[17:28:18.155]                       muffled <- FALSE
[17:28:18.155]                       if (inherits(cond, "message")) {
[17:28:18.155]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.155]                         if (muffled) 
[17:28:18.155]                           invokeRestart("muffleMessage")
[17:28:18.155]                       }
[17:28:18.155]                       else if (inherits(cond, "warning")) {
[17:28:18.155]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.155]                         if (muffled) 
[17:28:18.155]                           invokeRestart("muffleWarning")
[17:28:18.155]                       }
[17:28:18.155]                       else if (inherits(cond, "condition")) {
[17:28:18.155]                         if (!is.null(pattern)) {
[17:28:18.155]                           computeRestarts <- base::computeRestarts
[17:28:18.155]                           grepl <- base::grepl
[17:28:18.155]                           restarts <- computeRestarts(cond)
[17:28:18.155]                           for (restart in restarts) {
[17:28:18.155]                             name <- restart$name
[17:28:18.155]                             if (is.null(name)) 
[17:28:18.155]                               next
[17:28:18.155]                             if (!grepl(pattern, name)) 
[17:28:18.155]                               next
[17:28:18.155]                             invokeRestart(restart)
[17:28:18.155]                             muffled <- TRUE
[17:28:18.155]                             break
[17:28:18.155]                           }
[17:28:18.155]                         }
[17:28:18.155]                       }
[17:28:18.155]                       invisible(muffled)
[17:28:18.155]                     }
[17:28:18.155]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.155]                   }
[17:28:18.155]                 }
[17:28:18.155]                 else {
[17:28:18.155]                   if (TRUE) {
[17:28:18.155]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.155]                     {
[17:28:18.155]                       inherits <- base::inherits
[17:28:18.155]                       invokeRestart <- base::invokeRestart
[17:28:18.155]                       is.null <- base::is.null
[17:28:18.155]                       muffled <- FALSE
[17:28:18.155]                       if (inherits(cond, "message")) {
[17:28:18.155]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.155]                         if (muffled) 
[17:28:18.155]                           invokeRestart("muffleMessage")
[17:28:18.155]                       }
[17:28:18.155]                       else if (inherits(cond, "warning")) {
[17:28:18.155]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.155]                         if (muffled) 
[17:28:18.155]                           invokeRestart("muffleWarning")
[17:28:18.155]                       }
[17:28:18.155]                       else if (inherits(cond, "condition")) {
[17:28:18.155]                         if (!is.null(pattern)) {
[17:28:18.155]                           computeRestarts <- base::computeRestarts
[17:28:18.155]                           grepl <- base::grepl
[17:28:18.155]                           restarts <- computeRestarts(cond)
[17:28:18.155]                           for (restart in restarts) {
[17:28:18.155]                             name <- restart$name
[17:28:18.155]                             if (is.null(name)) 
[17:28:18.155]                               next
[17:28:18.155]                             if (!grepl(pattern, name)) 
[17:28:18.155]                               next
[17:28:18.155]                             invokeRestart(restart)
[17:28:18.155]                             muffled <- TRUE
[17:28:18.155]                             break
[17:28:18.155]                           }
[17:28:18.155]                         }
[17:28:18.155]                       }
[17:28:18.155]                       invisible(muffled)
[17:28:18.155]                     }
[17:28:18.155]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.155]                   }
[17:28:18.155]                 }
[17:28:18.155]             }
[17:28:18.155]         }))
[17:28:18.155]     }, error = function(ex) {
[17:28:18.155]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.155]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.155]                 ...future.rng), started = ...future.startTime, 
[17:28:18.155]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.155]             version = "1.8"), class = "FutureResult")
[17:28:18.155]     }, finally = {
[17:28:18.155]         if (!identical(...future.workdir, getwd())) 
[17:28:18.155]             setwd(...future.workdir)
[17:28:18.155]         {
[17:28:18.155]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.155]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.155]             }
[17:28:18.155]             base::options(...future.oldOptions)
[17:28:18.155]             if (.Platform$OS.type == "windows") {
[17:28:18.155]                 old_names <- names(...future.oldEnvVars)
[17:28:18.155]                 envs <- base::Sys.getenv()
[17:28:18.155]                 names <- names(envs)
[17:28:18.155]                 common <- intersect(names, old_names)
[17:28:18.155]                 added <- setdiff(names, old_names)
[17:28:18.155]                 removed <- setdiff(old_names, names)
[17:28:18.155]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.155]                   envs[common]]
[17:28:18.155]                 NAMES <- toupper(changed)
[17:28:18.155]                 args <- list()
[17:28:18.155]                 for (kk in seq_along(NAMES)) {
[17:28:18.155]                   name <- changed[[kk]]
[17:28:18.155]                   NAME <- NAMES[[kk]]
[17:28:18.155]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.155]                     next
[17:28:18.155]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.155]                 }
[17:28:18.155]                 NAMES <- toupper(added)
[17:28:18.155]                 for (kk in seq_along(NAMES)) {
[17:28:18.155]                   name <- added[[kk]]
[17:28:18.155]                   NAME <- NAMES[[kk]]
[17:28:18.155]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.155]                     next
[17:28:18.155]                   args[[name]] <- ""
[17:28:18.155]                 }
[17:28:18.155]                 NAMES <- toupper(removed)
[17:28:18.155]                 for (kk in seq_along(NAMES)) {
[17:28:18.155]                   name <- removed[[kk]]
[17:28:18.155]                   NAME <- NAMES[[kk]]
[17:28:18.155]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.155]                     next
[17:28:18.155]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.155]                 }
[17:28:18.155]                 if (length(args) > 0) 
[17:28:18.155]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.155]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.155]             }
[17:28:18.155]             else {
[17:28:18.155]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.155]             }
[17:28:18.155]             {
[17:28:18.155]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.155]                   0L) {
[17:28:18.155]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.155]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.155]                   base::options(opts)
[17:28:18.155]                 }
[17:28:18.155]                 {
[17:28:18.155]                   {
[17:28:18.155]                     base::assign(".Random.seed", c(10407L, -272798089L, 
[17:28:18.155]                     -315111812L, 149633403L, -1555199413L, 1104122703L, 
[17:28:18.155]                     -1159683708L), envir = base::globalenv(), 
[17:28:18.155]                       inherits = FALSE)
[17:28:18.155]                     NULL
[17:28:18.155]                   }
[17:28:18.155]                   options(future.plan = NULL)
[17:28:18.155]                   if (is.na(NA_character_)) 
[17:28:18.155]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.155]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.155]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.155]                     .init = FALSE)
[17:28:18.155]                 }
[17:28:18.155]             }
[17:28:18.155]         }
[17:28:18.155]     })
[17:28:18.155]     if (TRUE) {
[17:28:18.155]         base::sink(type = "output", split = FALSE)
[17:28:18.155]         if (TRUE) {
[17:28:18.155]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.155]         }
[17:28:18.155]         else {
[17:28:18.155]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.155]         }
[17:28:18.155]         base::close(...future.stdout)
[17:28:18.155]         ...future.stdout <- NULL
[17:28:18.155]     }
[17:28:18.155]     ...future.result$conditions <- ...future.conditions
[17:28:18.155]     ...future.result$finished <- base::Sys.time()
[17:28:18.155]     ...future.result
[17:28:18.155] }
[17:28:18.159] assign_globals() ...
[17:28:18.159] List of 1
[17:28:18.159]  $ x: int [1:4] 0 1 2 3
[17:28:18.159]  - attr(*, "where")=List of 1
[17:28:18.159]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.159]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.159]  - attr(*, "resolved")= logi FALSE
[17:28:18.159]  - attr(*, "total_size")= num 64
[17:28:18.159]  - attr(*, "already-done")= logi TRUE
[17:28:18.162] - copied 'x' to environment
[17:28:18.162] assign_globals() ... done
[17:28:18.163] plan(): Setting new future strategy stack:
[17:28:18.163] List of future strategies:
[17:28:18.163] 1. sequential:
[17:28:18.163]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.163]    - tweaked: FALSE
[17:28:18.163]    - call: NULL
[17:28:18.164] plan(): nbrOfWorkers() = 1
[17:28:18.166] plan(): Setting new future strategy stack:
[17:28:18.166] List of future strategies:
[17:28:18.166] 1. sequential:
[17:28:18.166]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.166]    - tweaked: FALSE
[17:28:18.166]    - call: plan(strategy)
[17:28:18.166] plan(): nbrOfWorkers() = 1
[17:28:18.167] SequentialFuture started (and completed)
[17:28:18.167] - Launch lazy future ... done
[17:28:18.167] run() for 'SequentialFuture' ... done
[17:28:18.168] getGlobalsAndPackages() ...
[17:28:18.168] Searching for globals...
[17:28:18.169] - globals found: [3] '{', 'sample', 'x'
[17:28:18.169] Searching for globals ... DONE
[17:28:18.169] Resolving globals: FALSE
[17:28:18.170] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.170] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.170] - globals: [1] 'x'
[17:28:18.171] 
[17:28:18.171] getGlobalsAndPackages() ... DONE
[17:28:18.171] run() for 'Future' ...
[17:28:18.171] - state: 'created'
[17:28:18.171] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.172] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.172] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.172]   - Field: 'label'
[17:28:18.172]   - Field: 'local'
[17:28:18.172]   - Field: 'owner'
[17:28:18.173]   - Field: 'envir'
[17:28:18.173]   - Field: 'packages'
[17:28:18.173]   - Field: 'gc'
[17:28:18.173]   - Field: 'conditions'
[17:28:18.173]   - Field: 'expr'
[17:28:18.174]   - Field: 'uuid'
[17:28:18.174]   - Field: 'seed'
[17:28:18.174]   - Field: 'version'
[17:28:18.174]   - Field: 'result'
[17:28:18.174]   - Field: 'asynchronous'
[17:28:18.174]   - Field: 'calls'
[17:28:18.175]   - Field: 'globals'
[17:28:18.175]   - Field: 'stdout'
[17:28:18.175]   - Field: 'earlySignal'
[17:28:18.175]   - Field: 'lazy'
[17:28:18.175]   - Field: 'state'
[17:28:18.175] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.176] - Launch lazy future ...
[17:28:18.176] Packages needed by the future expression (n = 0): <none>
[17:28:18.176] Packages needed by future strategies (n = 0): <none>
[17:28:18.176] {
[17:28:18.176]     {
[17:28:18.176]         {
[17:28:18.176]             ...future.startTime <- base::Sys.time()
[17:28:18.176]             {
[17:28:18.176]                 {
[17:28:18.176]                   {
[17:28:18.176]                     base::local({
[17:28:18.176]                       has_future <- base::requireNamespace("future", 
[17:28:18.176]                         quietly = TRUE)
[17:28:18.176]                       if (has_future) {
[17:28:18.176]                         ns <- base::getNamespace("future")
[17:28:18.176]                         version <- ns[[".package"]][["version"]]
[17:28:18.176]                         if (is.null(version)) 
[17:28:18.176]                           version <- utils::packageVersion("future")
[17:28:18.176]                       }
[17:28:18.176]                       else {
[17:28:18.176]                         version <- NULL
[17:28:18.176]                       }
[17:28:18.176]                       if (!has_future || version < "1.8.0") {
[17:28:18.176]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.176]                           "", base::R.version$version.string), 
[17:28:18.176]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.176]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.176]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.176]                             "release", "version")], collapse = " "), 
[17:28:18.176]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.176]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.176]                           info)
[17:28:18.176]                         info <- base::paste(info, collapse = "; ")
[17:28:18.176]                         if (!has_future) {
[17:28:18.176]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.176]                             info)
[17:28:18.176]                         }
[17:28:18.176]                         else {
[17:28:18.176]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.176]                             info, version)
[17:28:18.176]                         }
[17:28:18.176]                         base::stop(msg)
[17:28:18.176]                       }
[17:28:18.176]                     })
[17:28:18.176]                   }
[17:28:18.176]                   ...future.strategy.old <- future::plan("list")
[17:28:18.176]                   options(future.plan = NULL)
[17:28:18.176]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.176]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.176]                 }
[17:28:18.176]                 ...future.workdir <- getwd()
[17:28:18.176]             }
[17:28:18.176]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.176]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.176]         }
[17:28:18.176]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.176]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.176]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.176]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.176]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.176]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.176]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.176]             base::names(...future.oldOptions))
[17:28:18.176]     }
[17:28:18.176]     if (FALSE) {
[17:28:18.176]     }
[17:28:18.176]     else {
[17:28:18.176]         if (TRUE) {
[17:28:18.176]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.176]                 open = "w")
[17:28:18.176]         }
[17:28:18.176]         else {
[17:28:18.176]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.176]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.176]         }
[17:28:18.176]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.176]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.176]             base::sink(type = "output", split = FALSE)
[17:28:18.176]             base::close(...future.stdout)
[17:28:18.176]         }, add = TRUE)
[17:28:18.176]     }
[17:28:18.176]     ...future.frame <- base::sys.nframe()
[17:28:18.176]     ...future.conditions <- base::list()
[17:28:18.176]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.176]     if (FALSE) {
[17:28:18.176]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.176]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.176]     }
[17:28:18.176]     ...future.result <- base::tryCatch({
[17:28:18.176]         base::withCallingHandlers({
[17:28:18.176]             ...future.value <- base::withVisible(base::local({
[17:28:18.176]                 sample(x, size = 1L)
[17:28:18.176]             }))
[17:28:18.176]             future::FutureResult(value = ...future.value$value, 
[17:28:18.176]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.176]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.176]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.176]                     ...future.globalenv.names))
[17:28:18.176]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.176]         }, condition = base::local({
[17:28:18.176]             c <- base::c
[17:28:18.176]             inherits <- base::inherits
[17:28:18.176]             invokeRestart <- base::invokeRestart
[17:28:18.176]             length <- base::length
[17:28:18.176]             list <- base::list
[17:28:18.176]             seq.int <- base::seq.int
[17:28:18.176]             signalCondition <- base::signalCondition
[17:28:18.176]             sys.calls <- base::sys.calls
[17:28:18.176]             `[[` <- base::`[[`
[17:28:18.176]             `+` <- base::`+`
[17:28:18.176]             `<<-` <- base::`<<-`
[17:28:18.176]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.176]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.176]                   3L)]
[17:28:18.176]             }
[17:28:18.176]             function(cond) {
[17:28:18.176]                 is_error <- inherits(cond, "error")
[17:28:18.176]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.176]                   NULL)
[17:28:18.176]                 if (is_error) {
[17:28:18.176]                   sessionInformation <- function() {
[17:28:18.176]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.176]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.176]                       search = base::search(), system = base::Sys.info())
[17:28:18.176]                   }
[17:28:18.176]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.176]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.176]                     cond$call), session = sessionInformation(), 
[17:28:18.176]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.176]                   signalCondition(cond)
[17:28:18.176]                 }
[17:28:18.176]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.176]                 "immediateCondition"))) {
[17:28:18.176]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.176]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.176]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.176]                   if (TRUE && !signal) {
[17:28:18.176]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.176]                     {
[17:28:18.176]                       inherits <- base::inherits
[17:28:18.176]                       invokeRestart <- base::invokeRestart
[17:28:18.176]                       is.null <- base::is.null
[17:28:18.176]                       muffled <- FALSE
[17:28:18.176]                       if (inherits(cond, "message")) {
[17:28:18.176]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.176]                         if (muffled) 
[17:28:18.176]                           invokeRestart("muffleMessage")
[17:28:18.176]                       }
[17:28:18.176]                       else if (inherits(cond, "warning")) {
[17:28:18.176]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.176]                         if (muffled) 
[17:28:18.176]                           invokeRestart("muffleWarning")
[17:28:18.176]                       }
[17:28:18.176]                       else if (inherits(cond, "condition")) {
[17:28:18.176]                         if (!is.null(pattern)) {
[17:28:18.176]                           computeRestarts <- base::computeRestarts
[17:28:18.176]                           grepl <- base::grepl
[17:28:18.176]                           restarts <- computeRestarts(cond)
[17:28:18.176]                           for (restart in restarts) {
[17:28:18.176]                             name <- restart$name
[17:28:18.176]                             if (is.null(name)) 
[17:28:18.176]                               next
[17:28:18.176]                             if (!grepl(pattern, name)) 
[17:28:18.176]                               next
[17:28:18.176]                             invokeRestart(restart)
[17:28:18.176]                             muffled <- TRUE
[17:28:18.176]                             break
[17:28:18.176]                           }
[17:28:18.176]                         }
[17:28:18.176]                       }
[17:28:18.176]                       invisible(muffled)
[17:28:18.176]                     }
[17:28:18.176]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.176]                   }
[17:28:18.176]                 }
[17:28:18.176]                 else {
[17:28:18.176]                   if (TRUE) {
[17:28:18.176]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.176]                     {
[17:28:18.176]                       inherits <- base::inherits
[17:28:18.176]                       invokeRestart <- base::invokeRestart
[17:28:18.176]                       is.null <- base::is.null
[17:28:18.176]                       muffled <- FALSE
[17:28:18.176]                       if (inherits(cond, "message")) {
[17:28:18.176]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.176]                         if (muffled) 
[17:28:18.176]                           invokeRestart("muffleMessage")
[17:28:18.176]                       }
[17:28:18.176]                       else if (inherits(cond, "warning")) {
[17:28:18.176]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.176]                         if (muffled) 
[17:28:18.176]                           invokeRestart("muffleWarning")
[17:28:18.176]                       }
[17:28:18.176]                       else if (inherits(cond, "condition")) {
[17:28:18.176]                         if (!is.null(pattern)) {
[17:28:18.176]                           computeRestarts <- base::computeRestarts
[17:28:18.176]                           grepl <- base::grepl
[17:28:18.176]                           restarts <- computeRestarts(cond)
[17:28:18.176]                           for (restart in restarts) {
[17:28:18.176]                             name <- restart$name
[17:28:18.176]                             if (is.null(name)) 
[17:28:18.176]                               next
[17:28:18.176]                             if (!grepl(pattern, name)) 
[17:28:18.176]                               next
[17:28:18.176]                             invokeRestart(restart)
[17:28:18.176]                             muffled <- TRUE
[17:28:18.176]                             break
[17:28:18.176]                           }
[17:28:18.176]                         }
[17:28:18.176]                       }
[17:28:18.176]                       invisible(muffled)
[17:28:18.176]                     }
[17:28:18.176]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.176]                   }
[17:28:18.176]                 }
[17:28:18.176]             }
[17:28:18.176]         }))
[17:28:18.176]     }, error = function(ex) {
[17:28:18.176]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.176]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.176]                 ...future.rng), started = ...future.startTime, 
[17:28:18.176]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.176]             version = "1.8"), class = "FutureResult")
[17:28:18.176]     }, finally = {
[17:28:18.176]         if (!identical(...future.workdir, getwd())) 
[17:28:18.176]             setwd(...future.workdir)
[17:28:18.176]         {
[17:28:18.176]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.176]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.176]             }
[17:28:18.176]             base::options(...future.oldOptions)
[17:28:18.176]             if (.Platform$OS.type == "windows") {
[17:28:18.176]                 old_names <- names(...future.oldEnvVars)
[17:28:18.176]                 envs <- base::Sys.getenv()
[17:28:18.176]                 names <- names(envs)
[17:28:18.176]                 common <- intersect(names, old_names)
[17:28:18.176]                 added <- setdiff(names, old_names)
[17:28:18.176]                 removed <- setdiff(old_names, names)
[17:28:18.176]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.176]                   envs[common]]
[17:28:18.176]                 NAMES <- toupper(changed)
[17:28:18.176]                 args <- list()
[17:28:18.176]                 for (kk in seq_along(NAMES)) {
[17:28:18.176]                   name <- changed[[kk]]
[17:28:18.176]                   NAME <- NAMES[[kk]]
[17:28:18.176]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.176]                     next
[17:28:18.176]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.176]                 }
[17:28:18.176]                 NAMES <- toupper(added)
[17:28:18.176]                 for (kk in seq_along(NAMES)) {
[17:28:18.176]                   name <- added[[kk]]
[17:28:18.176]                   NAME <- NAMES[[kk]]
[17:28:18.176]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.176]                     next
[17:28:18.176]                   args[[name]] <- ""
[17:28:18.176]                 }
[17:28:18.176]                 NAMES <- toupper(removed)
[17:28:18.176]                 for (kk in seq_along(NAMES)) {
[17:28:18.176]                   name <- removed[[kk]]
[17:28:18.176]                   NAME <- NAMES[[kk]]
[17:28:18.176]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.176]                     next
[17:28:18.176]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.176]                 }
[17:28:18.176]                 if (length(args) > 0) 
[17:28:18.176]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.176]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.176]             }
[17:28:18.176]             else {
[17:28:18.176]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.176]             }
[17:28:18.176]             {
[17:28:18.176]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.176]                   0L) {
[17:28:18.176]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.176]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.176]                   base::options(opts)
[17:28:18.176]                 }
[17:28:18.176]                 {
[17:28:18.176]                   {
[17:28:18.176]                     base::assign(".Random.seed", c(10407L, 149633403L, 
[17:28:18.176]                     -1673542288L, -576396632L, -1159683708L, 
[17:28:18.176]                     -1814401748L, -1322062327L), envir = base::globalenv(), 
[17:28:18.176]                       inherits = FALSE)
[17:28:18.176]                     NULL
[17:28:18.176]                   }
[17:28:18.176]                   options(future.plan = NULL)
[17:28:18.176]                   if (is.na(NA_character_)) 
[17:28:18.176]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.176]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.176]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.176]                     .init = FALSE)
[17:28:18.176]                 }
[17:28:18.176]             }
[17:28:18.176]         }
[17:28:18.176]     })
[17:28:18.176]     if (TRUE) {
[17:28:18.176]         base::sink(type = "output", split = FALSE)
[17:28:18.176]         if (TRUE) {
[17:28:18.176]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.176]         }
[17:28:18.176]         else {
[17:28:18.176]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.176]         }
[17:28:18.176]         base::close(...future.stdout)
[17:28:18.176]         ...future.stdout <- NULL
[17:28:18.176]     }
[17:28:18.176]     ...future.result$conditions <- ...future.conditions
[17:28:18.176]     ...future.result$finished <- base::Sys.time()
[17:28:18.176]     ...future.result
[17:28:18.176] }
[17:28:18.180] assign_globals() ...
[17:28:18.180] List of 1
[17:28:18.180]  $ x: int [1:4] 0 1 2 3
[17:28:18.180]  - attr(*, "where")=List of 1
[17:28:18.180]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.180]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.180]  - attr(*, "resolved")= logi FALSE
[17:28:18.180]  - attr(*, "total_size")= num 64
[17:28:18.180]  - attr(*, "already-done")= logi TRUE
[17:28:18.183] - copied 'x' to environment
[17:28:18.183] assign_globals() ... done
[17:28:18.184] plan(): Setting new future strategy stack:
[17:28:18.184] List of future strategies:
[17:28:18.184] 1. sequential:
[17:28:18.184]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.184]    - tweaked: FALSE
[17:28:18.184]    - call: NULL
[17:28:18.185] plan(): nbrOfWorkers() = 1
[17:28:18.186] plan(): Setting new future strategy stack:
[17:28:18.186] List of future strategies:
[17:28:18.186] 1. sequential:
[17:28:18.186]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.186]    - tweaked: FALSE
[17:28:18.186]    - call: plan(strategy)
[17:28:18.187] plan(): nbrOfWorkers() = 1
[17:28:18.187] SequentialFuture started (and completed)
[17:28:18.187] - Launch lazy future ... done
[17:28:18.187] run() for 'SequentialFuture' ... done
[17:28:18.188] getGlobalsAndPackages() ...
[17:28:18.188] Searching for globals...
[17:28:18.189] - globals found: [3] '{', 'sample', 'x'
[17:28:18.189] Searching for globals ... DONE
[17:28:18.189] Resolving globals: FALSE
[17:28:18.190] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.190] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.190] - globals: [1] 'x'
[17:28:18.191] 
[17:28:18.191] getGlobalsAndPackages() ... DONE
[17:28:18.191] run() for 'Future' ...
[17:28:18.191] - state: 'created'
[17:28:18.192] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.192] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.192] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.193]   - Field: 'label'
[17:28:18.193]   - Field: 'local'
[17:28:18.194]   - Field: 'owner'
[17:28:18.194]   - Field: 'envir'
[17:28:18.194]   - Field: 'packages'
[17:28:18.194]   - Field: 'gc'
[17:28:18.194]   - Field: 'conditions'
[17:28:18.194]   - Field: 'expr'
[17:28:18.195]   - Field: 'uuid'
[17:28:18.195]   - Field: 'seed'
[17:28:18.195]   - Field: 'version'
[17:28:18.195]   - Field: 'result'
[17:28:18.195]   - Field: 'asynchronous'
[17:28:18.195]   - Field: 'calls'
[17:28:18.196]   - Field: 'globals'
[17:28:18.196]   - Field: 'stdout'
[17:28:18.196]   - Field: 'earlySignal'
[17:28:18.196]   - Field: 'lazy'
[17:28:18.196]   - Field: 'state'
[17:28:18.197] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.197] - Launch lazy future ...
[17:28:18.197] Packages needed by the future expression (n = 0): <none>
[17:28:18.197] Packages needed by future strategies (n = 0): <none>
[17:28:18.198] {
[17:28:18.198]     {
[17:28:18.198]         {
[17:28:18.198]             ...future.startTime <- base::Sys.time()
[17:28:18.198]             {
[17:28:18.198]                 {
[17:28:18.198]                   {
[17:28:18.198]                     base::local({
[17:28:18.198]                       has_future <- base::requireNamespace("future", 
[17:28:18.198]                         quietly = TRUE)
[17:28:18.198]                       if (has_future) {
[17:28:18.198]                         ns <- base::getNamespace("future")
[17:28:18.198]                         version <- ns[[".package"]][["version"]]
[17:28:18.198]                         if (is.null(version)) 
[17:28:18.198]                           version <- utils::packageVersion("future")
[17:28:18.198]                       }
[17:28:18.198]                       else {
[17:28:18.198]                         version <- NULL
[17:28:18.198]                       }
[17:28:18.198]                       if (!has_future || version < "1.8.0") {
[17:28:18.198]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.198]                           "", base::R.version$version.string), 
[17:28:18.198]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.198]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.198]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.198]                             "release", "version")], collapse = " "), 
[17:28:18.198]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.198]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.198]                           info)
[17:28:18.198]                         info <- base::paste(info, collapse = "; ")
[17:28:18.198]                         if (!has_future) {
[17:28:18.198]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.198]                             info)
[17:28:18.198]                         }
[17:28:18.198]                         else {
[17:28:18.198]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.198]                             info, version)
[17:28:18.198]                         }
[17:28:18.198]                         base::stop(msg)
[17:28:18.198]                       }
[17:28:18.198]                     })
[17:28:18.198]                   }
[17:28:18.198]                   ...future.strategy.old <- future::plan("list")
[17:28:18.198]                   options(future.plan = NULL)
[17:28:18.198]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.198]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.198]                 }
[17:28:18.198]                 ...future.workdir <- getwd()
[17:28:18.198]             }
[17:28:18.198]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.198]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.198]         }
[17:28:18.198]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.198]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.198]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.198]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.198]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.198]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.198]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.198]             base::names(...future.oldOptions))
[17:28:18.198]     }
[17:28:18.198]     if (FALSE) {
[17:28:18.198]     }
[17:28:18.198]     else {
[17:28:18.198]         if (TRUE) {
[17:28:18.198]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.198]                 open = "w")
[17:28:18.198]         }
[17:28:18.198]         else {
[17:28:18.198]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.198]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.198]         }
[17:28:18.198]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.198]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.198]             base::sink(type = "output", split = FALSE)
[17:28:18.198]             base::close(...future.stdout)
[17:28:18.198]         }, add = TRUE)
[17:28:18.198]     }
[17:28:18.198]     ...future.frame <- base::sys.nframe()
[17:28:18.198]     ...future.conditions <- base::list()
[17:28:18.198]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.198]     if (FALSE) {
[17:28:18.198]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.198]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.198]     }
[17:28:18.198]     ...future.result <- base::tryCatch({
[17:28:18.198]         base::withCallingHandlers({
[17:28:18.198]             ...future.value <- base::withVisible(base::local({
[17:28:18.198]                 sample(x, size = 1L)
[17:28:18.198]             }))
[17:28:18.198]             future::FutureResult(value = ...future.value$value, 
[17:28:18.198]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.198]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.198]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.198]                     ...future.globalenv.names))
[17:28:18.198]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.198]         }, condition = base::local({
[17:28:18.198]             c <- base::c
[17:28:18.198]             inherits <- base::inherits
[17:28:18.198]             invokeRestart <- base::invokeRestart
[17:28:18.198]             length <- base::length
[17:28:18.198]             list <- base::list
[17:28:18.198]             seq.int <- base::seq.int
[17:28:18.198]             signalCondition <- base::signalCondition
[17:28:18.198]             sys.calls <- base::sys.calls
[17:28:18.198]             `[[` <- base::`[[`
[17:28:18.198]             `+` <- base::`+`
[17:28:18.198]             `<<-` <- base::`<<-`
[17:28:18.198]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.198]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.198]                   3L)]
[17:28:18.198]             }
[17:28:18.198]             function(cond) {
[17:28:18.198]                 is_error <- inherits(cond, "error")
[17:28:18.198]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.198]                   NULL)
[17:28:18.198]                 if (is_error) {
[17:28:18.198]                   sessionInformation <- function() {
[17:28:18.198]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.198]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.198]                       search = base::search(), system = base::Sys.info())
[17:28:18.198]                   }
[17:28:18.198]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.198]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.198]                     cond$call), session = sessionInformation(), 
[17:28:18.198]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.198]                   signalCondition(cond)
[17:28:18.198]                 }
[17:28:18.198]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.198]                 "immediateCondition"))) {
[17:28:18.198]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.198]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.198]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.198]                   if (TRUE && !signal) {
[17:28:18.198]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.198]                     {
[17:28:18.198]                       inherits <- base::inherits
[17:28:18.198]                       invokeRestart <- base::invokeRestart
[17:28:18.198]                       is.null <- base::is.null
[17:28:18.198]                       muffled <- FALSE
[17:28:18.198]                       if (inherits(cond, "message")) {
[17:28:18.198]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.198]                         if (muffled) 
[17:28:18.198]                           invokeRestart("muffleMessage")
[17:28:18.198]                       }
[17:28:18.198]                       else if (inherits(cond, "warning")) {
[17:28:18.198]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.198]                         if (muffled) 
[17:28:18.198]                           invokeRestart("muffleWarning")
[17:28:18.198]                       }
[17:28:18.198]                       else if (inherits(cond, "condition")) {
[17:28:18.198]                         if (!is.null(pattern)) {
[17:28:18.198]                           computeRestarts <- base::computeRestarts
[17:28:18.198]                           grepl <- base::grepl
[17:28:18.198]                           restarts <- computeRestarts(cond)
[17:28:18.198]                           for (restart in restarts) {
[17:28:18.198]                             name <- restart$name
[17:28:18.198]                             if (is.null(name)) 
[17:28:18.198]                               next
[17:28:18.198]                             if (!grepl(pattern, name)) 
[17:28:18.198]                               next
[17:28:18.198]                             invokeRestart(restart)
[17:28:18.198]                             muffled <- TRUE
[17:28:18.198]                             break
[17:28:18.198]                           }
[17:28:18.198]                         }
[17:28:18.198]                       }
[17:28:18.198]                       invisible(muffled)
[17:28:18.198]                     }
[17:28:18.198]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.198]                   }
[17:28:18.198]                 }
[17:28:18.198]                 else {
[17:28:18.198]                   if (TRUE) {
[17:28:18.198]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.198]                     {
[17:28:18.198]                       inherits <- base::inherits
[17:28:18.198]                       invokeRestart <- base::invokeRestart
[17:28:18.198]                       is.null <- base::is.null
[17:28:18.198]                       muffled <- FALSE
[17:28:18.198]                       if (inherits(cond, "message")) {
[17:28:18.198]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.198]                         if (muffled) 
[17:28:18.198]                           invokeRestart("muffleMessage")
[17:28:18.198]                       }
[17:28:18.198]                       else if (inherits(cond, "warning")) {
[17:28:18.198]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.198]                         if (muffled) 
[17:28:18.198]                           invokeRestart("muffleWarning")
[17:28:18.198]                       }
[17:28:18.198]                       else if (inherits(cond, "condition")) {
[17:28:18.198]                         if (!is.null(pattern)) {
[17:28:18.198]                           computeRestarts <- base::computeRestarts
[17:28:18.198]                           grepl <- base::grepl
[17:28:18.198]                           restarts <- computeRestarts(cond)
[17:28:18.198]                           for (restart in restarts) {
[17:28:18.198]                             name <- restart$name
[17:28:18.198]                             if (is.null(name)) 
[17:28:18.198]                               next
[17:28:18.198]                             if (!grepl(pattern, name)) 
[17:28:18.198]                               next
[17:28:18.198]                             invokeRestart(restart)
[17:28:18.198]                             muffled <- TRUE
[17:28:18.198]                             break
[17:28:18.198]                           }
[17:28:18.198]                         }
[17:28:18.198]                       }
[17:28:18.198]                       invisible(muffled)
[17:28:18.198]                     }
[17:28:18.198]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.198]                   }
[17:28:18.198]                 }
[17:28:18.198]             }
[17:28:18.198]         }))
[17:28:18.198]     }, error = function(ex) {
[17:28:18.198]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.198]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.198]                 ...future.rng), started = ...future.startTime, 
[17:28:18.198]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.198]             version = "1.8"), class = "FutureResult")
[17:28:18.198]     }, finally = {
[17:28:18.198]         if (!identical(...future.workdir, getwd())) 
[17:28:18.198]             setwd(...future.workdir)
[17:28:18.198]         {
[17:28:18.198]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.198]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.198]             }
[17:28:18.198]             base::options(...future.oldOptions)
[17:28:18.198]             if (.Platform$OS.type == "windows") {
[17:28:18.198]                 old_names <- names(...future.oldEnvVars)
[17:28:18.198]                 envs <- base::Sys.getenv()
[17:28:18.198]                 names <- names(envs)
[17:28:18.198]                 common <- intersect(names, old_names)
[17:28:18.198]                 added <- setdiff(names, old_names)
[17:28:18.198]                 removed <- setdiff(old_names, names)
[17:28:18.198]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.198]                   envs[common]]
[17:28:18.198]                 NAMES <- toupper(changed)
[17:28:18.198]                 args <- list()
[17:28:18.198]                 for (kk in seq_along(NAMES)) {
[17:28:18.198]                   name <- changed[[kk]]
[17:28:18.198]                   NAME <- NAMES[[kk]]
[17:28:18.198]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.198]                     next
[17:28:18.198]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.198]                 }
[17:28:18.198]                 NAMES <- toupper(added)
[17:28:18.198]                 for (kk in seq_along(NAMES)) {
[17:28:18.198]                   name <- added[[kk]]
[17:28:18.198]                   NAME <- NAMES[[kk]]
[17:28:18.198]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.198]                     next
[17:28:18.198]                   args[[name]] <- ""
[17:28:18.198]                 }
[17:28:18.198]                 NAMES <- toupper(removed)
[17:28:18.198]                 for (kk in seq_along(NAMES)) {
[17:28:18.198]                   name <- removed[[kk]]
[17:28:18.198]                   NAME <- NAMES[[kk]]
[17:28:18.198]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.198]                     next
[17:28:18.198]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.198]                 }
[17:28:18.198]                 if (length(args) > 0) 
[17:28:18.198]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.198]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.198]             }
[17:28:18.198]             else {
[17:28:18.198]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.198]             }
[17:28:18.198]             {
[17:28:18.198]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.198]                   0L) {
[17:28:18.198]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.198]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.198]                   base::options(opts)
[17:28:18.198]                 }
[17:28:18.198]                 {
[17:28:18.198]                   {
[17:28:18.198]                     base::assign(".Random.seed", c(10407L, -576396632L, 
[17:28:18.198]                     1024199107L, 1713854453L, -1322062327L, 2062659684L, 
[17:28:18.198]                     131382765L), envir = base::globalenv(), inherits = FALSE)
[17:28:18.198]                     NULL
[17:28:18.198]                   }
[17:28:18.198]                   options(future.plan = NULL)
[17:28:18.198]                   if (is.na(NA_character_)) 
[17:28:18.198]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.198]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.198]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.198]                     .init = FALSE)
[17:28:18.198]                 }
[17:28:18.198]             }
[17:28:18.198]         }
[17:28:18.198]     })
[17:28:18.198]     if (TRUE) {
[17:28:18.198]         base::sink(type = "output", split = FALSE)
[17:28:18.198]         if (TRUE) {
[17:28:18.198]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.198]         }
[17:28:18.198]         else {
[17:28:18.198]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.198]         }
[17:28:18.198]         base::close(...future.stdout)
[17:28:18.198]         ...future.stdout <- NULL
[17:28:18.198]     }
[17:28:18.198]     ...future.result$conditions <- ...future.conditions
[17:28:18.198]     ...future.result$finished <- base::Sys.time()
[17:28:18.198]     ...future.result
[17:28:18.198] }
[17:28:18.201] assign_globals() ...
[17:28:18.201] List of 1
[17:28:18.201]  $ x: int [1:4] 0 1 2 3
[17:28:18.201]  - attr(*, "where")=List of 1
[17:28:18.201]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.201]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.201]  - attr(*, "resolved")= logi FALSE
[17:28:18.201]  - attr(*, "total_size")= num 64
[17:28:18.201]  - attr(*, "already-done")= logi TRUE
[17:28:18.204] - copied 'x' to environment
[17:28:18.205] assign_globals() ... done
[17:28:18.205] plan(): Setting new future strategy stack:
[17:28:18.205] List of future strategies:
[17:28:18.205] 1. sequential:
[17:28:18.205]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.205]    - tweaked: FALSE
[17:28:18.205]    - call: NULL
[17:28:18.206] plan(): nbrOfWorkers() = 1
[17:28:18.207] plan(): Setting new future strategy stack:
[17:28:18.207] List of future strategies:
[17:28:18.207] 1. sequential:
[17:28:18.207]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.207]    - tweaked: FALSE
[17:28:18.207]    - call: plan(strategy)
[17:28:18.208] plan(): nbrOfWorkers() = 1
[17:28:18.208] SequentialFuture started (and completed)
[17:28:18.208] - Launch lazy future ... done
[17:28:18.208] run() for 'SequentialFuture' ... done
[[1]]
[1] 0

[[2]]
[1] 1

[[3]]
[1] 2

[[4]]
[1] 0

[17:28:18.209] getGlobalsAndPackages() ...
[17:28:18.210] Searching for globals...
[17:28:18.211] - globals found: [3] '{', 'sample', 'x'
[17:28:18.211] Searching for globals ... DONE
[17:28:18.211] Resolving globals: FALSE
[17:28:18.212] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.212] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.212] - globals: [1] 'x'
[17:28:18.212] 
[17:28:18.212] getGlobalsAndPackages() ... DONE
[17:28:18.213] run() for 'Future' ...
[17:28:18.213] - state: 'created'
[17:28:18.213] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.214] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.214] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.214]   - Field: 'label'
[17:28:18.214]   - Field: 'local'
[17:28:18.214]   - Field: 'owner'
[17:28:18.214]   - Field: 'envir'
[17:28:18.215]   - Field: 'packages'
[17:28:18.215]   - Field: 'gc'
[17:28:18.215]   - Field: 'conditions'
[17:28:18.215]   - Field: 'expr'
[17:28:18.215]   - Field: 'uuid'
[17:28:18.215]   - Field: 'seed'
[17:28:18.216]   - Field: 'version'
[17:28:18.216]   - Field: 'result'
[17:28:18.216]   - Field: 'asynchronous'
[17:28:18.216]   - Field: 'calls'
[17:28:18.216]   - Field: 'globals'
[17:28:18.217]   - Field: 'stdout'
[17:28:18.217]   - Field: 'earlySignal'
[17:28:18.217]   - Field: 'lazy'
[17:28:18.217]   - Field: 'state'
[17:28:18.217] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.217] - Launch lazy future ...
[17:28:18.218] Packages needed by the future expression (n = 0): <none>
[17:28:18.218] Packages needed by future strategies (n = 0): <none>
[17:28:18.218] {
[17:28:18.218]     {
[17:28:18.218]         {
[17:28:18.218]             ...future.startTime <- base::Sys.time()
[17:28:18.218]             {
[17:28:18.218]                 {
[17:28:18.218]                   {
[17:28:18.218]                     base::local({
[17:28:18.218]                       has_future <- base::requireNamespace("future", 
[17:28:18.218]                         quietly = TRUE)
[17:28:18.218]                       if (has_future) {
[17:28:18.218]                         ns <- base::getNamespace("future")
[17:28:18.218]                         version <- ns[[".package"]][["version"]]
[17:28:18.218]                         if (is.null(version)) 
[17:28:18.218]                           version <- utils::packageVersion("future")
[17:28:18.218]                       }
[17:28:18.218]                       else {
[17:28:18.218]                         version <- NULL
[17:28:18.218]                       }
[17:28:18.218]                       if (!has_future || version < "1.8.0") {
[17:28:18.218]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.218]                           "", base::R.version$version.string), 
[17:28:18.218]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.218]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.218]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.218]                             "release", "version")], collapse = " "), 
[17:28:18.218]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.218]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.218]                           info)
[17:28:18.218]                         info <- base::paste(info, collapse = "; ")
[17:28:18.218]                         if (!has_future) {
[17:28:18.218]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.218]                             info)
[17:28:18.218]                         }
[17:28:18.218]                         else {
[17:28:18.218]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.218]                             info, version)
[17:28:18.218]                         }
[17:28:18.218]                         base::stop(msg)
[17:28:18.218]                       }
[17:28:18.218]                     })
[17:28:18.218]                   }
[17:28:18.218]                   ...future.strategy.old <- future::plan("list")
[17:28:18.218]                   options(future.plan = NULL)
[17:28:18.218]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.218]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.218]                 }
[17:28:18.218]                 ...future.workdir <- getwd()
[17:28:18.218]             }
[17:28:18.218]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.218]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.218]         }
[17:28:18.218]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.218]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.218]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.218]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.218]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.218]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.218]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.218]             base::names(...future.oldOptions))
[17:28:18.218]     }
[17:28:18.218]     if (FALSE) {
[17:28:18.218]     }
[17:28:18.218]     else {
[17:28:18.218]         if (TRUE) {
[17:28:18.218]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.218]                 open = "w")
[17:28:18.218]         }
[17:28:18.218]         else {
[17:28:18.218]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.218]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.218]         }
[17:28:18.218]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.218]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.218]             base::sink(type = "output", split = FALSE)
[17:28:18.218]             base::close(...future.stdout)
[17:28:18.218]         }, add = TRUE)
[17:28:18.218]     }
[17:28:18.218]     ...future.frame <- base::sys.nframe()
[17:28:18.218]     ...future.conditions <- base::list()
[17:28:18.218]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.218]     if (FALSE) {
[17:28:18.218]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.218]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.218]     }
[17:28:18.218]     ...future.result <- base::tryCatch({
[17:28:18.218]         base::withCallingHandlers({
[17:28:18.218]             ...future.value <- base::withVisible(base::local({
[17:28:18.218]                 sample(x, size = 1L)
[17:28:18.218]             }))
[17:28:18.218]             future::FutureResult(value = ...future.value$value, 
[17:28:18.218]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.218]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.218]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.218]                     ...future.globalenv.names))
[17:28:18.218]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.218]         }, condition = base::local({
[17:28:18.218]             c <- base::c
[17:28:18.218]             inherits <- base::inherits
[17:28:18.218]             invokeRestart <- base::invokeRestart
[17:28:18.218]             length <- base::length
[17:28:18.218]             list <- base::list
[17:28:18.218]             seq.int <- base::seq.int
[17:28:18.218]             signalCondition <- base::signalCondition
[17:28:18.218]             sys.calls <- base::sys.calls
[17:28:18.218]             `[[` <- base::`[[`
[17:28:18.218]             `+` <- base::`+`
[17:28:18.218]             `<<-` <- base::`<<-`
[17:28:18.218]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.218]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.218]                   3L)]
[17:28:18.218]             }
[17:28:18.218]             function(cond) {
[17:28:18.218]                 is_error <- inherits(cond, "error")
[17:28:18.218]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.218]                   NULL)
[17:28:18.218]                 if (is_error) {
[17:28:18.218]                   sessionInformation <- function() {
[17:28:18.218]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.218]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.218]                       search = base::search(), system = base::Sys.info())
[17:28:18.218]                   }
[17:28:18.218]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.218]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.218]                     cond$call), session = sessionInformation(), 
[17:28:18.218]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.218]                   signalCondition(cond)
[17:28:18.218]                 }
[17:28:18.218]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.218]                 "immediateCondition"))) {
[17:28:18.218]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.218]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.218]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.218]                   if (TRUE && !signal) {
[17:28:18.218]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.218]                     {
[17:28:18.218]                       inherits <- base::inherits
[17:28:18.218]                       invokeRestart <- base::invokeRestart
[17:28:18.218]                       is.null <- base::is.null
[17:28:18.218]                       muffled <- FALSE
[17:28:18.218]                       if (inherits(cond, "message")) {
[17:28:18.218]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.218]                         if (muffled) 
[17:28:18.218]                           invokeRestart("muffleMessage")
[17:28:18.218]                       }
[17:28:18.218]                       else if (inherits(cond, "warning")) {
[17:28:18.218]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.218]                         if (muffled) 
[17:28:18.218]                           invokeRestart("muffleWarning")
[17:28:18.218]                       }
[17:28:18.218]                       else if (inherits(cond, "condition")) {
[17:28:18.218]                         if (!is.null(pattern)) {
[17:28:18.218]                           computeRestarts <- base::computeRestarts
[17:28:18.218]                           grepl <- base::grepl
[17:28:18.218]                           restarts <- computeRestarts(cond)
[17:28:18.218]                           for (restart in restarts) {
[17:28:18.218]                             name <- restart$name
[17:28:18.218]                             if (is.null(name)) 
[17:28:18.218]                               next
[17:28:18.218]                             if (!grepl(pattern, name)) 
[17:28:18.218]                               next
[17:28:18.218]                             invokeRestart(restart)
[17:28:18.218]                             muffled <- TRUE
[17:28:18.218]                             break
[17:28:18.218]                           }
[17:28:18.218]                         }
[17:28:18.218]                       }
[17:28:18.218]                       invisible(muffled)
[17:28:18.218]                     }
[17:28:18.218]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.218]                   }
[17:28:18.218]                 }
[17:28:18.218]                 else {
[17:28:18.218]                   if (TRUE) {
[17:28:18.218]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.218]                     {
[17:28:18.218]                       inherits <- base::inherits
[17:28:18.218]                       invokeRestart <- base::invokeRestart
[17:28:18.218]                       is.null <- base::is.null
[17:28:18.218]                       muffled <- FALSE
[17:28:18.218]                       if (inherits(cond, "message")) {
[17:28:18.218]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.218]                         if (muffled) 
[17:28:18.218]                           invokeRestart("muffleMessage")
[17:28:18.218]                       }
[17:28:18.218]                       else if (inherits(cond, "warning")) {
[17:28:18.218]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.218]                         if (muffled) 
[17:28:18.218]                           invokeRestart("muffleWarning")
[17:28:18.218]                       }
[17:28:18.218]                       else if (inherits(cond, "condition")) {
[17:28:18.218]                         if (!is.null(pattern)) {
[17:28:18.218]                           computeRestarts <- base::computeRestarts
[17:28:18.218]                           grepl <- base::grepl
[17:28:18.218]                           restarts <- computeRestarts(cond)
[17:28:18.218]                           for (restart in restarts) {
[17:28:18.218]                             name <- restart$name
[17:28:18.218]                             if (is.null(name)) 
[17:28:18.218]                               next
[17:28:18.218]                             if (!grepl(pattern, name)) 
[17:28:18.218]                               next
[17:28:18.218]                             invokeRestart(restart)
[17:28:18.218]                             muffled <- TRUE
[17:28:18.218]                             break
[17:28:18.218]                           }
[17:28:18.218]                         }
[17:28:18.218]                       }
[17:28:18.218]                       invisible(muffled)
[17:28:18.218]                     }
[17:28:18.218]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.218]                   }
[17:28:18.218]                 }
[17:28:18.218]             }
[17:28:18.218]         }))
[17:28:18.218]     }, error = function(ex) {
[17:28:18.218]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.218]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.218]                 ...future.rng), started = ...future.startTime, 
[17:28:18.218]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.218]             version = "1.8"), class = "FutureResult")
[17:28:18.218]     }, finally = {
[17:28:18.218]         if (!identical(...future.workdir, getwd())) 
[17:28:18.218]             setwd(...future.workdir)
[17:28:18.218]         {
[17:28:18.218]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.218]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.218]             }
[17:28:18.218]             base::options(...future.oldOptions)
[17:28:18.218]             if (.Platform$OS.type == "windows") {
[17:28:18.218]                 old_names <- names(...future.oldEnvVars)
[17:28:18.218]                 envs <- base::Sys.getenv()
[17:28:18.218]                 names <- names(envs)
[17:28:18.218]                 common <- intersect(names, old_names)
[17:28:18.218]                 added <- setdiff(names, old_names)
[17:28:18.218]                 removed <- setdiff(old_names, names)
[17:28:18.218]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.218]                   envs[common]]
[17:28:18.218]                 NAMES <- toupper(changed)
[17:28:18.218]                 args <- list()
[17:28:18.218]                 for (kk in seq_along(NAMES)) {
[17:28:18.218]                   name <- changed[[kk]]
[17:28:18.218]                   NAME <- NAMES[[kk]]
[17:28:18.218]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.218]                     next
[17:28:18.218]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.218]                 }
[17:28:18.218]                 NAMES <- toupper(added)
[17:28:18.218]                 for (kk in seq_along(NAMES)) {
[17:28:18.218]                   name <- added[[kk]]
[17:28:18.218]                   NAME <- NAMES[[kk]]
[17:28:18.218]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.218]                     next
[17:28:18.218]                   args[[name]] <- ""
[17:28:18.218]                 }
[17:28:18.218]                 NAMES <- toupper(removed)
[17:28:18.218]                 for (kk in seq_along(NAMES)) {
[17:28:18.218]                   name <- removed[[kk]]
[17:28:18.218]                   NAME <- NAMES[[kk]]
[17:28:18.218]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.218]                     next
[17:28:18.218]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.218]                 }
[17:28:18.218]                 if (length(args) > 0) 
[17:28:18.218]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.218]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.218]             }
[17:28:18.218]             else {
[17:28:18.218]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.218]             }
[17:28:18.218]             {
[17:28:18.218]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.218]                   0L) {
[17:28:18.218]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.218]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.218]                   base::options(opts)
[17:28:18.218]                 }
[17:28:18.218]                 {
[17:28:18.218]                   {
[17:28:18.218]                     base::assign(".Random.seed", c(10407L, 2047656601L, 
[17:28:18.218]                     -1391193963L, -1632727667L, -1586534332L, 
[17:28:18.218]                     -471806345L, 865592900L), envir = base::globalenv(), 
[17:28:18.218]                       inherits = FALSE)
[17:28:18.218]                     NULL
[17:28:18.218]                   }
[17:28:18.218]                   options(future.plan = NULL)
[17:28:18.218]                   if (is.na(NA_character_)) 
[17:28:18.218]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.218]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.218]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.218]                     .init = FALSE)
[17:28:18.218]                 }
[17:28:18.218]             }
[17:28:18.218]         }
[17:28:18.218]     })
[17:28:18.218]     if (TRUE) {
[17:28:18.218]         base::sink(type = "output", split = FALSE)
[17:28:18.218]         if (TRUE) {
[17:28:18.218]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.218]         }
[17:28:18.218]         else {
[17:28:18.218]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.218]         }
[17:28:18.218]         base::close(...future.stdout)
[17:28:18.218]         ...future.stdout <- NULL
[17:28:18.218]     }
[17:28:18.218]     ...future.result$conditions <- ...future.conditions
[17:28:18.218]     ...future.result$finished <- base::Sys.time()
[17:28:18.218]     ...future.result
[17:28:18.218] }
[17:28:18.222] assign_globals() ...
[17:28:18.222] List of 1
[17:28:18.222]  $ x: int [1:4] 0 1 2 3
[17:28:18.222]  - attr(*, "where")=List of 1
[17:28:18.222]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.222]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.222]  - attr(*, "resolved")= logi FALSE
[17:28:18.222]  - attr(*, "total_size")= num 64
[17:28:18.222]  - attr(*, "already-done")= logi TRUE
[17:28:18.226] - copied 'x' to environment
[17:28:18.226] assign_globals() ... done
[17:28:18.227] plan(): Setting new future strategy stack:
[17:28:18.227] List of future strategies:
[17:28:18.227] 1. sequential:
[17:28:18.227]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.227]    - tweaked: FALSE
[17:28:18.227]    - call: NULL
[17:28:18.227] plan(): nbrOfWorkers() = 1
[17:28:18.229] plan(): Setting new future strategy stack:
[17:28:18.229] List of future strategies:
[17:28:18.229] 1. sequential:
[17:28:18.229]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.229]    - tweaked: FALSE
[17:28:18.229]    - call: plan(strategy)
[17:28:18.229] plan(): nbrOfWorkers() = 1
[17:28:18.230] SequentialFuture started (and completed)
[17:28:18.230] - Launch lazy future ... done
[17:28:18.230] run() for 'SequentialFuture' ... done
[17:28:18.231] getGlobalsAndPackages() ...
[17:28:18.231] Searching for globals...
[17:28:18.232] - globals found: [3] '{', 'sample', 'x'
[17:28:18.232] Searching for globals ... DONE
[17:28:18.232] Resolving globals: FALSE
[17:28:18.233] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.233] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.233] - globals: [1] 'x'
[17:28:18.233] 
[17:28:18.234] getGlobalsAndPackages() ... DONE
[17:28:18.234] run() for 'Future' ...
[17:28:18.234] - state: 'created'
[17:28:18.234] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.235] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.235] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.235]   - Field: 'label'
[17:28:18.235]   - Field: 'local'
[17:28:18.235]   - Field: 'owner'
[17:28:18.236]   - Field: 'envir'
[17:28:18.236]   - Field: 'packages'
[17:28:18.236]   - Field: 'gc'
[17:28:18.236]   - Field: 'conditions'
[17:28:18.236]   - Field: 'expr'
[17:28:18.236]   - Field: 'uuid'
[17:28:18.237]   - Field: 'seed'
[17:28:18.237]   - Field: 'version'
[17:28:18.237]   - Field: 'result'
[17:28:18.237]   - Field: 'asynchronous'
[17:28:18.237]   - Field: 'calls'
[17:28:18.237]   - Field: 'globals'
[17:28:18.238]   - Field: 'stdout'
[17:28:18.238]   - Field: 'earlySignal'
[17:28:18.238]   - Field: 'lazy'
[17:28:18.238]   - Field: 'state'
[17:28:18.238] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.238] - Launch lazy future ...
[17:28:18.239] Packages needed by the future expression (n = 0): <none>
[17:28:18.239] Packages needed by future strategies (n = 0): <none>
[17:28:18.239] {
[17:28:18.239]     {
[17:28:18.239]         {
[17:28:18.239]             ...future.startTime <- base::Sys.time()
[17:28:18.239]             {
[17:28:18.239]                 {
[17:28:18.239]                   {
[17:28:18.239]                     base::local({
[17:28:18.239]                       has_future <- base::requireNamespace("future", 
[17:28:18.239]                         quietly = TRUE)
[17:28:18.239]                       if (has_future) {
[17:28:18.239]                         ns <- base::getNamespace("future")
[17:28:18.239]                         version <- ns[[".package"]][["version"]]
[17:28:18.239]                         if (is.null(version)) 
[17:28:18.239]                           version <- utils::packageVersion("future")
[17:28:18.239]                       }
[17:28:18.239]                       else {
[17:28:18.239]                         version <- NULL
[17:28:18.239]                       }
[17:28:18.239]                       if (!has_future || version < "1.8.0") {
[17:28:18.239]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.239]                           "", base::R.version$version.string), 
[17:28:18.239]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.239]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.239]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.239]                             "release", "version")], collapse = " "), 
[17:28:18.239]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.239]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.239]                           info)
[17:28:18.239]                         info <- base::paste(info, collapse = "; ")
[17:28:18.239]                         if (!has_future) {
[17:28:18.239]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.239]                             info)
[17:28:18.239]                         }
[17:28:18.239]                         else {
[17:28:18.239]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.239]                             info, version)
[17:28:18.239]                         }
[17:28:18.239]                         base::stop(msg)
[17:28:18.239]                       }
[17:28:18.239]                     })
[17:28:18.239]                   }
[17:28:18.239]                   ...future.strategy.old <- future::plan("list")
[17:28:18.239]                   options(future.plan = NULL)
[17:28:18.239]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.239]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.239]                 }
[17:28:18.239]                 ...future.workdir <- getwd()
[17:28:18.239]             }
[17:28:18.239]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.239]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.239]         }
[17:28:18.239]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.239]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.239]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.239]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.239]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.239]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.239]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.239]             base::names(...future.oldOptions))
[17:28:18.239]     }
[17:28:18.239]     if (FALSE) {
[17:28:18.239]     }
[17:28:18.239]     else {
[17:28:18.239]         if (TRUE) {
[17:28:18.239]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.239]                 open = "w")
[17:28:18.239]         }
[17:28:18.239]         else {
[17:28:18.239]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.239]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.239]         }
[17:28:18.239]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.239]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.239]             base::sink(type = "output", split = FALSE)
[17:28:18.239]             base::close(...future.stdout)
[17:28:18.239]         }, add = TRUE)
[17:28:18.239]     }
[17:28:18.239]     ...future.frame <- base::sys.nframe()
[17:28:18.239]     ...future.conditions <- base::list()
[17:28:18.239]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.239]     if (FALSE) {
[17:28:18.239]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.239]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.239]     }
[17:28:18.239]     ...future.result <- base::tryCatch({
[17:28:18.239]         base::withCallingHandlers({
[17:28:18.239]             ...future.value <- base::withVisible(base::local({
[17:28:18.239]                 sample(x, size = 1L)
[17:28:18.239]             }))
[17:28:18.239]             future::FutureResult(value = ...future.value$value, 
[17:28:18.239]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.239]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.239]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.239]                     ...future.globalenv.names))
[17:28:18.239]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.239]         }, condition = base::local({
[17:28:18.239]             c <- base::c
[17:28:18.239]             inherits <- base::inherits
[17:28:18.239]             invokeRestart <- base::invokeRestart
[17:28:18.239]             length <- base::length
[17:28:18.239]             list <- base::list
[17:28:18.239]             seq.int <- base::seq.int
[17:28:18.239]             signalCondition <- base::signalCondition
[17:28:18.239]             sys.calls <- base::sys.calls
[17:28:18.239]             `[[` <- base::`[[`
[17:28:18.239]             `+` <- base::`+`
[17:28:18.239]             `<<-` <- base::`<<-`
[17:28:18.239]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.239]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.239]                   3L)]
[17:28:18.239]             }
[17:28:18.239]             function(cond) {
[17:28:18.239]                 is_error <- inherits(cond, "error")
[17:28:18.239]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.239]                   NULL)
[17:28:18.239]                 if (is_error) {
[17:28:18.239]                   sessionInformation <- function() {
[17:28:18.239]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.239]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.239]                       search = base::search(), system = base::Sys.info())
[17:28:18.239]                   }
[17:28:18.239]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.239]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.239]                     cond$call), session = sessionInformation(), 
[17:28:18.239]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.239]                   signalCondition(cond)
[17:28:18.239]                 }
[17:28:18.239]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.239]                 "immediateCondition"))) {
[17:28:18.239]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.239]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.239]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.239]                   if (TRUE && !signal) {
[17:28:18.239]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.239]                     {
[17:28:18.239]                       inherits <- base::inherits
[17:28:18.239]                       invokeRestart <- base::invokeRestart
[17:28:18.239]                       is.null <- base::is.null
[17:28:18.239]                       muffled <- FALSE
[17:28:18.239]                       if (inherits(cond, "message")) {
[17:28:18.239]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.239]                         if (muffled) 
[17:28:18.239]                           invokeRestart("muffleMessage")
[17:28:18.239]                       }
[17:28:18.239]                       else if (inherits(cond, "warning")) {
[17:28:18.239]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.239]                         if (muffled) 
[17:28:18.239]                           invokeRestart("muffleWarning")
[17:28:18.239]                       }
[17:28:18.239]                       else if (inherits(cond, "condition")) {
[17:28:18.239]                         if (!is.null(pattern)) {
[17:28:18.239]                           computeRestarts <- base::computeRestarts
[17:28:18.239]                           grepl <- base::grepl
[17:28:18.239]                           restarts <- computeRestarts(cond)
[17:28:18.239]                           for (restart in restarts) {
[17:28:18.239]                             name <- restart$name
[17:28:18.239]                             if (is.null(name)) 
[17:28:18.239]                               next
[17:28:18.239]                             if (!grepl(pattern, name)) 
[17:28:18.239]                               next
[17:28:18.239]                             invokeRestart(restart)
[17:28:18.239]                             muffled <- TRUE
[17:28:18.239]                             break
[17:28:18.239]                           }
[17:28:18.239]                         }
[17:28:18.239]                       }
[17:28:18.239]                       invisible(muffled)
[17:28:18.239]                     }
[17:28:18.239]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.239]                   }
[17:28:18.239]                 }
[17:28:18.239]                 else {
[17:28:18.239]                   if (TRUE) {
[17:28:18.239]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.239]                     {
[17:28:18.239]                       inherits <- base::inherits
[17:28:18.239]                       invokeRestart <- base::invokeRestart
[17:28:18.239]                       is.null <- base::is.null
[17:28:18.239]                       muffled <- FALSE
[17:28:18.239]                       if (inherits(cond, "message")) {
[17:28:18.239]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.239]                         if (muffled) 
[17:28:18.239]                           invokeRestart("muffleMessage")
[17:28:18.239]                       }
[17:28:18.239]                       else if (inherits(cond, "warning")) {
[17:28:18.239]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.239]                         if (muffled) 
[17:28:18.239]                           invokeRestart("muffleWarning")
[17:28:18.239]                       }
[17:28:18.239]                       else if (inherits(cond, "condition")) {
[17:28:18.239]                         if (!is.null(pattern)) {
[17:28:18.239]                           computeRestarts <- base::computeRestarts
[17:28:18.239]                           grepl <- base::grepl
[17:28:18.239]                           restarts <- computeRestarts(cond)
[17:28:18.239]                           for (restart in restarts) {
[17:28:18.239]                             name <- restart$name
[17:28:18.239]                             if (is.null(name)) 
[17:28:18.239]                               next
[17:28:18.239]                             if (!grepl(pattern, name)) 
[17:28:18.239]                               next
[17:28:18.239]                             invokeRestart(restart)
[17:28:18.239]                             muffled <- TRUE
[17:28:18.239]                             break
[17:28:18.239]                           }
[17:28:18.239]                         }
[17:28:18.239]                       }
[17:28:18.239]                       invisible(muffled)
[17:28:18.239]                     }
[17:28:18.239]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.239]                   }
[17:28:18.239]                 }
[17:28:18.239]             }
[17:28:18.239]         }))
[17:28:18.239]     }, error = function(ex) {
[17:28:18.239]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.239]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.239]                 ...future.rng), started = ...future.startTime, 
[17:28:18.239]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.239]             version = "1.8"), class = "FutureResult")
[17:28:18.239]     }, finally = {
[17:28:18.239]         if (!identical(...future.workdir, getwd())) 
[17:28:18.239]             setwd(...future.workdir)
[17:28:18.239]         {
[17:28:18.239]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.239]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.239]             }
[17:28:18.239]             base::options(...future.oldOptions)
[17:28:18.239]             if (.Platform$OS.type == "windows") {
[17:28:18.239]                 old_names <- names(...future.oldEnvVars)
[17:28:18.239]                 envs <- base::Sys.getenv()
[17:28:18.239]                 names <- names(envs)
[17:28:18.239]                 common <- intersect(names, old_names)
[17:28:18.239]                 added <- setdiff(names, old_names)
[17:28:18.239]                 removed <- setdiff(old_names, names)
[17:28:18.239]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.239]                   envs[common]]
[17:28:18.239]                 NAMES <- toupper(changed)
[17:28:18.239]                 args <- list()
[17:28:18.239]                 for (kk in seq_along(NAMES)) {
[17:28:18.239]                   name <- changed[[kk]]
[17:28:18.239]                   NAME <- NAMES[[kk]]
[17:28:18.239]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.239]                     next
[17:28:18.239]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.239]                 }
[17:28:18.239]                 NAMES <- toupper(added)
[17:28:18.239]                 for (kk in seq_along(NAMES)) {
[17:28:18.239]                   name <- added[[kk]]
[17:28:18.239]                   NAME <- NAMES[[kk]]
[17:28:18.239]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.239]                     next
[17:28:18.239]                   args[[name]] <- ""
[17:28:18.239]                 }
[17:28:18.239]                 NAMES <- toupper(removed)
[17:28:18.239]                 for (kk in seq_along(NAMES)) {
[17:28:18.239]                   name <- removed[[kk]]
[17:28:18.239]                   NAME <- NAMES[[kk]]
[17:28:18.239]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.239]                     next
[17:28:18.239]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.239]                 }
[17:28:18.239]                 if (length(args) > 0) 
[17:28:18.239]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.239]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.239]             }
[17:28:18.239]             else {
[17:28:18.239]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.239]             }
[17:28:18.239]             {
[17:28:18.239]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.239]                   0L) {
[17:28:18.239]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.239]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.239]                   base::options(opts)
[17:28:18.239]                 }
[17:28:18.239]                 {
[17:28:18.239]                   {
[17:28:18.239]                     base::assign(".Random.seed", c(10407L, -1632727667L, 
[17:28:18.239]                     1654911898L, 1881022227L, 865592900L, 697753043L, 
[17:28:18.239]                     1914436937L), envir = base::globalenv(), 
[17:28:18.239]                       inherits = FALSE)
[17:28:18.239]                     NULL
[17:28:18.239]                   }
[17:28:18.239]                   options(future.plan = NULL)
[17:28:18.239]                   if (is.na(NA_character_)) 
[17:28:18.239]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.239]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.239]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.239]                     .init = FALSE)
[17:28:18.239]                 }
[17:28:18.239]             }
[17:28:18.239]         }
[17:28:18.239]     })
[17:28:18.239]     if (TRUE) {
[17:28:18.239]         base::sink(type = "output", split = FALSE)
[17:28:18.239]         if (TRUE) {
[17:28:18.239]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.239]         }
[17:28:18.239]         else {
[17:28:18.239]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.239]         }
[17:28:18.239]         base::close(...future.stdout)
[17:28:18.239]         ...future.stdout <- NULL
[17:28:18.239]     }
[17:28:18.239]     ...future.result$conditions <- ...future.conditions
[17:28:18.239]     ...future.result$finished <- base::Sys.time()
[17:28:18.239]     ...future.result
[17:28:18.239] }
[17:28:18.243] assign_globals() ...
[17:28:18.243] List of 1
[17:28:18.243]  $ x: int [1:4] 0 1 2 3
[17:28:18.243]  - attr(*, "where")=List of 1
[17:28:18.243]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.243]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.243]  - attr(*, "resolved")= logi FALSE
[17:28:18.243]  - attr(*, "total_size")= num 64
[17:28:18.243]  - attr(*, "already-done")= logi TRUE
[17:28:18.246] - copied 'x' to environment
[17:28:18.246] assign_globals() ... done
[17:28:18.247] plan(): Setting new future strategy stack:
[17:28:18.247] List of future strategies:
[17:28:18.247] 1. sequential:
[17:28:18.247]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.247]    - tweaked: FALSE
[17:28:18.247]    - call: NULL
[17:28:18.247] plan(): nbrOfWorkers() = 1
[17:28:18.249] plan(): Setting new future strategy stack:
[17:28:18.249] List of future strategies:
[17:28:18.249] 1. sequential:
[17:28:18.249]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.249]    - tweaked: FALSE
[17:28:18.249]    - call: plan(strategy)
[17:28:18.249] plan(): nbrOfWorkers() = 1
[17:28:18.250] SequentialFuture started (and completed)
[17:28:18.250] - Launch lazy future ... done
[17:28:18.250] run() for 'SequentialFuture' ... done
[17:28:18.251] getGlobalsAndPackages() ...
[17:28:18.251] Searching for globals...
[17:28:18.254] - globals found: [3] '{', 'sample', 'x'
[17:28:18.254] Searching for globals ... DONE
[17:28:18.254] Resolving globals: FALSE
[17:28:18.255] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.255] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.255] - globals: [1] 'x'
[17:28:18.256] 
[17:28:18.256] getGlobalsAndPackages() ... DONE
[17:28:18.256] run() for 'Future' ...
[17:28:18.256] - state: 'created'
[17:28:18.256] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.257] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.257] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.257]   - Field: 'label'
[17:28:18.257]   - Field: 'local'
[17:28:18.258]   - Field: 'owner'
[17:28:18.258]   - Field: 'envir'
[17:28:18.258]   - Field: 'packages'
[17:28:18.258]   - Field: 'gc'
[17:28:18.258]   - Field: 'conditions'
[17:28:18.258]   - Field: 'expr'
[17:28:18.259]   - Field: 'uuid'
[17:28:18.259]   - Field: 'seed'
[17:28:18.259]   - Field: 'version'
[17:28:18.259]   - Field: 'result'
[17:28:18.259]   - Field: 'asynchronous'
[17:28:18.260]   - Field: 'calls'
[17:28:18.260]   - Field: 'globals'
[17:28:18.260]   - Field: 'stdout'
[17:28:18.260]   - Field: 'earlySignal'
[17:28:18.260]   - Field: 'lazy'
[17:28:18.260]   - Field: 'state'
[17:28:18.261] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.261] - Launch lazy future ...
[17:28:18.261] Packages needed by the future expression (n = 0): <none>
[17:28:18.261] Packages needed by future strategies (n = 0): <none>
[17:28:18.262] {
[17:28:18.262]     {
[17:28:18.262]         {
[17:28:18.262]             ...future.startTime <- base::Sys.time()
[17:28:18.262]             {
[17:28:18.262]                 {
[17:28:18.262]                   {
[17:28:18.262]                     base::local({
[17:28:18.262]                       has_future <- base::requireNamespace("future", 
[17:28:18.262]                         quietly = TRUE)
[17:28:18.262]                       if (has_future) {
[17:28:18.262]                         ns <- base::getNamespace("future")
[17:28:18.262]                         version <- ns[[".package"]][["version"]]
[17:28:18.262]                         if (is.null(version)) 
[17:28:18.262]                           version <- utils::packageVersion("future")
[17:28:18.262]                       }
[17:28:18.262]                       else {
[17:28:18.262]                         version <- NULL
[17:28:18.262]                       }
[17:28:18.262]                       if (!has_future || version < "1.8.0") {
[17:28:18.262]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.262]                           "", base::R.version$version.string), 
[17:28:18.262]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.262]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.262]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.262]                             "release", "version")], collapse = " "), 
[17:28:18.262]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.262]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.262]                           info)
[17:28:18.262]                         info <- base::paste(info, collapse = "; ")
[17:28:18.262]                         if (!has_future) {
[17:28:18.262]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.262]                             info)
[17:28:18.262]                         }
[17:28:18.262]                         else {
[17:28:18.262]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.262]                             info, version)
[17:28:18.262]                         }
[17:28:18.262]                         base::stop(msg)
[17:28:18.262]                       }
[17:28:18.262]                     })
[17:28:18.262]                   }
[17:28:18.262]                   ...future.strategy.old <- future::plan("list")
[17:28:18.262]                   options(future.plan = NULL)
[17:28:18.262]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.262]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.262]                 }
[17:28:18.262]                 ...future.workdir <- getwd()
[17:28:18.262]             }
[17:28:18.262]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.262]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.262]         }
[17:28:18.262]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.262]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.262]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.262]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.262]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.262]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.262]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.262]             base::names(...future.oldOptions))
[17:28:18.262]     }
[17:28:18.262]     if (FALSE) {
[17:28:18.262]     }
[17:28:18.262]     else {
[17:28:18.262]         if (TRUE) {
[17:28:18.262]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.262]                 open = "w")
[17:28:18.262]         }
[17:28:18.262]         else {
[17:28:18.262]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.262]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.262]         }
[17:28:18.262]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.262]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.262]             base::sink(type = "output", split = FALSE)
[17:28:18.262]             base::close(...future.stdout)
[17:28:18.262]         }, add = TRUE)
[17:28:18.262]     }
[17:28:18.262]     ...future.frame <- base::sys.nframe()
[17:28:18.262]     ...future.conditions <- base::list()
[17:28:18.262]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.262]     if (FALSE) {
[17:28:18.262]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.262]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.262]     }
[17:28:18.262]     ...future.result <- base::tryCatch({
[17:28:18.262]         base::withCallingHandlers({
[17:28:18.262]             ...future.value <- base::withVisible(base::local({
[17:28:18.262]                 sample(x, size = 1L)
[17:28:18.262]             }))
[17:28:18.262]             future::FutureResult(value = ...future.value$value, 
[17:28:18.262]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.262]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.262]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.262]                     ...future.globalenv.names))
[17:28:18.262]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.262]         }, condition = base::local({
[17:28:18.262]             c <- base::c
[17:28:18.262]             inherits <- base::inherits
[17:28:18.262]             invokeRestart <- base::invokeRestart
[17:28:18.262]             length <- base::length
[17:28:18.262]             list <- base::list
[17:28:18.262]             seq.int <- base::seq.int
[17:28:18.262]             signalCondition <- base::signalCondition
[17:28:18.262]             sys.calls <- base::sys.calls
[17:28:18.262]             `[[` <- base::`[[`
[17:28:18.262]             `+` <- base::`+`
[17:28:18.262]             `<<-` <- base::`<<-`
[17:28:18.262]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.262]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.262]                   3L)]
[17:28:18.262]             }
[17:28:18.262]             function(cond) {
[17:28:18.262]                 is_error <- inherits(cond, "error")
[17:28:18.262]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.262]                   NULL)
[17:28:18.262]                 if (is_error) {
[17:28:18.262]                   sessionInformation <- function() {
[17:28:18.262]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.262]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.262]                       search = base::search(), system = base::Sys.info())
[17:28:18.262]                   }
[17:28:18.262]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.262]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.262]                     cond$call), session = sessionInformation(), 
[17:28:18.262]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.262]                   signalCondition(cond)
[17:28:18.262]                 }
[17:28:18.262]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.262]                 "immediateCondition"))) {
[17:28:18.262]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.262]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.262]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.262]                   if (TRUE && !signal) {
[17:28:18.262]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.262]                     {
[17:28:18.262]                       inherits <- base::inherits
[17:28:18.262]                       invokeRestart <- base::invokeRestart
[17:28:18.262]                       is.null <- base::is.null
[17:28:18.262]                       muffled <- FALSE
[17:28:18.262]                       if (inherits(cond, "message")) {
[17:28:18.262]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.262]                         if (muffled) 
[17:28:18.262]                           invokeRestart("muffleMessage")
[17:28:18.262]                       }
[17:28:18.262]                       else if (inherits(cond, "warning")) {
[17:28:18.262]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.262]                         if (muffled) 
[17:28:18.262]                           invokeRestart("muffleWarning")
[17:28:18.262]                       }
[17:28:18.262]                       else if (inherits(cond, "condition")) {
[17:28:18.262]                         if (!is.null(pattern)) {
[17:28:18.262]                           computeRestarts <- base::computeRestarts
[17:28:18.262]                           grepl <- base::grepl
[17:28:18.262]                           restarts <- computeRestarts(cond)
[17:28:18.262]                           for (restart in restarts) {
[17:28:18.262]                             name <- restart$name
[17:28:18.262]                             if (is.null(name)) 
[17:28:18.262]                               next
[17:28:18.262]                             if (!grepl(pattern, name)) 
[17:28:18.262]                               next
[17:28:18.262]                             invokeRestart(restart)
[17:28:18.262]                             muffled <- TRUE
[17:28:18.262]                             break
[17:28:18.262]                           }
[17:28:18.262]                         }
[17:28:18.262]                       }
[17:28:18.262]                       invisible(muffled)
[17:28:18.262]                     }
[17:28:18.262]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.262]                   }
[17:28:18.262]                 }
[17:28:18.262]                 else {
[17:28:18.262]                   if (TRUE) {
[17:28:18.262]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.262]                     {
[17:28:18.262]                       inherits <- base::inherits
[17:28:18.262]                       invokeRestart <- base::invokeRestart
[17:28:18.262]                       is.null <- base::is.null
[17:28:18.262]                       muffled <- FALSE
[17:28:18.262]                       if (inherits(cond, "message")) {
[17:28:18.262]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.262]                         if (muffled) 
[17:28:18.262]                           invokeRestart("muffleMessage")
[17:28:18.262]                       }
[17:28:18.262]                       else if (inherits(cond, "warning")) {
[17:28:18.262]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.262]                         if (muffled) 
[17:28:18.262]                           invokeRestart("muffleWarning")
[17:28:18.262]                       }
[17:28:18.262]                       else if (inherits(cond, "condition")) {
[17:28:18.262]                         if (!is.null(pattern)) {
[17:28:18.262]                           computeRestarts <- base::computeRestarts
[17:28:18.262]                           grepl <- base::grepl
[17:28:18.262]                           restarts <- computeRestarts(cond)
[17:28:18.262]                           for (restart in restarts) {
[17:28:18.262]                             name <- restart$name
[17:28:18.262]                             if (is.null(name)) 
[17:28:18.262]                               next
[17:28:18.262]                             if (!grepl(pattern, name)) 
[17:28:18.262]                               next
[17:28:18.262]                             invokeRestart(restart)
[17:28:18.262]                             muffled <- TRUE
[17:28:18.262]                             break
[17:28:18.262]                           }
[17:28:18.262]                         }
[17:28:18.262]                       }
[17:28:18.262]                       invisible(muffled)
[17:28:18.262]                     }
[17:28:18.262]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.262]                   }
[17:28:18.262]                 }
[17:28:18.262]             }
[17:28:18.262]         }))
[17:28:18.262]     }, error = function(ex) {
[17:28:18.262]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.262]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.262]                 ...future.rng), started = ...future.startTime, 
[17:28:18.262]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.262]             version = "1.8"), class = "FutureResult")
[17:28:18.262]     }, finally = {
[17:28:18.262]         if (!identical(...future.workdir, getwd())) 
[17:28:18.262]             setwd(...future.workdir)
[17:28:18.262]         {
[17:28:18.262]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.262]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.262]             }
[17:28:18.262]             base::options(...future.oldOptions)
[17:28:18.262]             if (.Platform$OS.type == "windows") {
[17:28:18.262]                 old_names <- names(...future.oldEnvVars)
[17:28:18.262]                 envs <- base::Sys.getenv()
[17:28:18.262]                 names <- names(envs)
[17:28:18.262]                 common <- intersect(names, old_names)
[17:28:18.262]                 added <- setdiff(names, old_names)
[17:28:18.262]                 removed <- setdiff(old_names, names)
[17:28:18.262]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.262]                   envs[common]]
[17:28:18.262]                 NAMES <- toupper(changed)
[17:28:18.262]                 args <- list()
[17:28:18.262]                 for (kk in seq_along(NAMES)) {
[17:28:18.262]                   name <- changed[[kk]]
[17:28:18.262]                   NAME <- NAMES[[kk]]
[17:28:18.262]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.262]                     next
[17:28:18.262]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.262]                 }
[17:28:18.262]                 NAMES <- toupper(added)
[17:28:18.262]                 for (kk in seq_along(NAMES)) {
[17:28:18.262]                   name <- added[[kk]]
[17:28:18.262]                   NAME <- NAMES[[kk]]
[17:28:18.262]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.262]                     next
[17:28:18.262]                   args[[name]] <- ""
[17:28:18.262]                 }
[17:28:18.262]                 NAMES <- toupper(removed)
[17:28:18.262]                 for (kk in seq_along(NAMES)) {
[17:28:18.262]                   name <- removed[[kk]]
[17:28:18.262]                   NAME <- NAMES[[kk]]
[17:28:18.262]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.262]                     next
[17:28:18.262]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.262]                 }
[17:28:18.262]                 if (length(args) > 0) 
[17:28:18.262]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.262]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.262]             }
[17:28:18.262]             else {
[17:28:18.262]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.262]             }
[17:28:18.262]             {
[17:28:18.262]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.262]                   0L) {
[17:28:18.262]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.262]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.262]                   base::options(opts)
[17:28:18.262]                 }
[17:28:18.262]                 {
[17:28:18.262]                   {
[17:28:18.262]                     base::assign(".Random.seed", c(10407L, 1881022227L, 
[17:28:18.262]                     -962939424L, 1544586554L, 1914436937L, -1916429131L, 
[17:28:18.262]                     -1969451661L), envir = base::globalenv(), 
[17:28:18.262]                       inherits = FALSE)
[17:28:18.262]                     NULL
[17:28:18.262]                   }
[17:28:18.262]                   options(future.plan = NULL)
[17:28:18.262]                   if (is.na(NA_character_)) 
[17:28:18.262]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.262]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.262]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.262]                     .init = FALSE)
[17:28:18.262]                 }
[17:28:18.262]             }
[17:28:18.262]         }
[17:28:18.262]     })
[17:28:18.262]     if (TRUE) {
[17:28:18.262]         base::sink(type = "output", split = FALSE)
[17:28:18.262]         if (TRUE) {
[17:28:18.262]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.262]         }
[17:28:18.262]         else {
[17:28:18.262]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.262]         }
[17:28:18.262]         base::close(...future.stdout)
[17:28:18.262]         ...future.stdout <- NULL
[17:28:18.262]     }
[17:28:18.262]     ...future.result$conditions <- ...future.conditions
[17:28:18.262]     ...future.result$finished <- base::Sys.time()
[17:28:18.262]     ...future.result
[17:28:18.262] }
[17:28:18.265] assign_globals() ...
[17:28:18.265] List of 1
[17:28:18.265]  $ x: int [1:4] 0 1 2 3
[17:28:18.265]  - attr(*, "where")=List of 1
[17:28:18.265]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.265]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.265]  - attr(*, "resolved")= logi FALSE
[17:28:18.265]  - attr(*, "total_size")= num 64
[17:28:18.265]  - attr(*, "already-done")= logi TRUE
[17:28:18.268] - copied 'x' to environment
[17:28:18.269] assign_globals() ... done
[17:28:18.269] plan(): Setting new future strategy stack:
[17:28:18.269] List of future strategies:
[17:28:18.269] 1. sequential:
[17:28:18.269]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.269]    - tweaked: FALSE
[17:28:18.269]    - call: NULL
[17:28:18.270] plan(): nbrOfWorkers() = 1
[17:28:18.271] plan(): Setting new future strategy stack:
[17:28:18.271] List of future strategies:
[17:28:18.271] 1. sequential:
[17:28:18.271]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.271]    - tweaked: FALSE
[17:28:18.271]    - call: plan(strategy)
[17:28:18.272] plan(): nbrOfWorkers() = 1
[17:28:18.272] SequentialFuture started (and completed)
[17:28:18.272] - Launch lazy future ... done
[17:28:18.272] run() for 'SequentialFuture' ... done
[17:28:18.273] getGlobalsAndPackages() ...
[17:28:18.273] Searching for globals...
[17:28:18.274] - globals found: [3] '{', 'sample', 'x'
[17:28:18.274] Searching for globals ... DONE
[17:28:18.274] Resolving globals: FALSE
[17:28:18.275] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.275] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.275] - globals: [1] 'x'
[17:28:18.276] 
[17:28:18.276] getGlobalsAndPackages() ... DONE
[17:28:18.276] run() for 'Future' ...
[17:28:18.276] - state: 'created'
[17:28:18.276] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.277] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.277] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.277]   - Field: 'label'
[17:28:18.277]   - Field: 'local'
[17:28:18.278]   - Field: 'owner'
[17:28:18.278]   - Field: 'envir'
[17:28:18.278]   - Field: 'packages'
[17:28:18.278]   - Field: 'gc'
[17:28:18.278]   - Field: 'conditions'
[17:28:18.278]   - Field: 'expr'
[17:28:18.279]   - Field: 'uuid'
[17:28:18.279]   - Field: 'seed'
[17:28:18.279]   - Field: 'version'
[17:28:18.279]   - Field: 'result'
[17:28:18.279]   - Field: 'asynchronous'
[17:28:18.279]   - Field: 'calls'
[17:28:18.280]   - Field: 'globals'
[17:28:18.280]   - Field: 'stdout'
[17:28:18.280]   - Field: 'earlySignal'
[17:28:18.280]   - Field: 'lazy'
[17:28:18.280]   - Field: 'state'
[17:28:18.281] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.281] - Launch lazy future ...
[17:28:18.281] Packages needed by the future expression (n = 0): <none>
[17:28:18.281] Packages needed by future strategies (n = 0): <none>
[17:28:18.282] {
[17:28:18.282]     {
[17:28:18.282]         {
[17:28:18.282]             ...future.startTime <- base::Sys.time()
[17:28:18.282]             {
[17:28:18.282]                 {
[17:28:18.282]                   {
[17:28:18.282]                     base::local({
[17:28:18.282]                       has_future <- base::requireNamespace("future", 
[17:28:18.282]                         quietly = TRUE)
[17:28:18.282]                       if (has_future) {
[17:28:18.282]                         ns <- base::getNamespace("future")
[17:28:18.282]                         version <- ns[[".package"]][["version"]]
[17:28:18.282]                         if (is.null(version)) 
[17:28:18.282]                           version <- utils::packageVersion("future")
[17:28:18.282]                       }
[17:28:18.282]                       else {
[17:28:18.282]                         version <- NULL
[17:28:18.282]                       }
[17:28:18.282]                       if (!has_future || version < "1.8.0") {
[17:28:18.282]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.282]                           "", base::R.version$version.string), 
[17:28:18.282]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.282]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.282]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.282]                             "release", "version")], collapse = " "), 
[17:28:18.282]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.282]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.282]                           info)
[17:28:18.282]                         info <- base::paste(info, collapse = "; ")
[17:28:18.282]                         if (!has_future) {
[17:28:18.282]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.282]                             info)
[17:28:18.282]                         }
[17:28:18.282]                         else {
[17:28:18.282]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.282]                             info, version)
[17:28:18.282]                         }
[17:28:18.282]                         base::stop(msg)
[17:28:18.282]                       }
[17:28:18.282]                     })
[17:28:18.282]                   }
[17:28:18.282]                   ...future.strategy.old <- future::plan("list")
[17:28:18.282]                   options(future.plan = NULL)
[17:28:18.282]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.282]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.282]                 }
[17:28:18.282]                 ...future.workdir <- getwd()
[17:28:18.282]             }
[17:28:18.282]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.282]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.282]         }
[17:28:18.282]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.282]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.282]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.282]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.282]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.282]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.282]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.282]             base::names(...future.oldOptions))
[17:28:18.282]     }
[17:28:18.282]     if (FALSE) {
[17:28:18.282]     }
[17:28:18.282]     else {
[17:28:18.282]         if (TRUE) {
[17:28:18.282]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.282]                 open = "w")
[17:28:18.282]         }
[17:28:18.282]         else {
[17:28:18.282]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.282]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.282]         }
[17:28:18.282]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.282]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.282]             base::sink(type = "output", split = FALSE)
[17:28:18.282]             base::close(...future.stdout)
[17:28:18.282]         }, add = TRUE)
[17:28:18.282]     }
[17:28:18.282]     ...future.frame <- base::sys.nframe()
[17:28:18.282]     ...future.conditions <- base::list()
[17:28:18.282]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.282]     if (FALSE) {
[17:28:18.282]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.282]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.282]     }
[17:28:18.282]     ...future.result <- base::tryCatch({
[17:28:18.282]         base::withCallingHandlers({
[17:28:18.282]             ...future.value <- base::withVisible(base::local({
[17:28:18.282]                 sample(x, size = 1L)
[17:28:18.282]             }))
[17:28:18.282]             future::FutureResult(value = ...future.value$value, 
[17:28:18.282]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.282]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.282]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.282]                     ...future.globalenv.names))
[17:28:18.282]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.282]         }, condition = base::local({
[17:28:18.282]             c <- base::c
[17:28:18.282]             inherits <- base::inherits
[17:28:18.282]             invokeRestart <- base::invokeRestart
[17:28:18.282]             length <- base::length
[17:28:18.282]             list <- base::list
[17:28:18.282]             seq.int <- base::seq.int
[17:28:18.282]             signalCondition <- base::signalCondition
[17:28:18.282]             sys.calls <- base::sys.calls
[17:28:18.282]             `[[` <- base::`[[`
[17:28:18.282]             `+` <- base::`+`
[17:28:18.282]             `<<-` <- base::`<<-`
[17:28:18.282]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.282]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.282]                   3L)]
[17:28:18.282]             }
[17:28:18.282]             function(cond) {
[17:28:18.282]                 is_error <- inherits(cond, "error")
[17:28:18.282]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.282]                   NULL)
[17:28:18.282]                 if (is_error) {
[17:28:18.282]                   sessionInformation <- function() {
[17:28:18.282]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.282]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.282]                       search = base::search(), system = base::Sys.info())
[17:28:18.282]                   }
[17:28:18.282]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.282]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.282]                     cond$call), session = sessionInformation(), 
[17:28:18.282]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.282]                   signalCondition(cond)
[17:28:18.282]                 }
[17:28:18.282]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.282]                 "immediateCondition"))) {
[17:28:18.282]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.282]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.282]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.282]                   if (TRUE && !signal) {
[17:28:18.282]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.282]                     {
[17:28:18.282]                       inherits <- base::inherits
[17:28:18.282]                       invokeRestart <- base::invokeRestart
[17:28:18.282]                       is.null <- base::is.null
[17:28:18.282]                       muffled <- FALSE
[17:28:18.282]                       if (inherits(cond, "message")) {
[17:28:18.282]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.282]                         if (muffled) 
[17:28:18.282]                           invokeRestart("muffleMessage")
[17:28:18.282]                       }
[17:28:18.282]                       else if (inherits(cond, "warning")) {
[17:28:18.282]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.282]                         if (muffled) 
[17:28:18.282]                           invokeRestart("muffleWarning")
[17:28:18.282]                       }
[17:28:18.282]                       else if (inherits(cond, "condition")) {
[17:28:18.282]                         if (!is.null(pattern)) {
[17:28:18.282]                           computeRestarts <- base::computeRestarts
[17:28:18.282]                           grepl <- base::grepl
[17:28:18.282]                           restarts <- computeRestarts(cond)
[17:28:18.282]                           for (restart in restarts) {
[17:28:18.282]                             name <- restart$name
[17:28:18.282]                             if (is.null(name)) 
[17:28:18.282]                               next
[17:28:18.282]                             if (!grepl(pattern, name)) 
[17:28:18.282]                               next
[17:28:18.282]                             invokeRestart(restart)
[17:28:18.282]                             muffled <- TRUE
[17:28:18.282]                             break
[17:28:18.282]                           }
[17:28:18.282]                         }
[17:28:18.282]                       }
[17:28:18.282]                       invisible(muffled)
[17:28:18.282]                     }
[17:28:18.282]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.282]                   }
[17:28:18.282]                 }
[17:28:18.282]                 else {
[17:28:18.282]                   if (TRUE) {
[17:28:18.282]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.282]                     {
[17:28:18.282]                       inherits <- base::inherits
[17:28:18.282]                       invokeRestart <- base::invokeRestart
[17:28:18.282]                       is.null <- base::is.null
[17:28:18.282]                       muffled <- FALSE
[17:28:18.282]                       if (inherits(cond, "message")) {
[17:28:18.282]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.282]                         if (muffled) 
[17:28:18.282]                           invokeRestart("muffleMessage")
[17:28:18.282]                       }
[17:28:18.282]                       else if (inherits(cond, "warning")) {
[17:28:18.282]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.282]                         if (muffled) 
[17:28:18.282]                           invokeRestart("muffleWarning")
[17:28:18.282]                       }
[17:28:18.282]                       else if (inherits(cond, "condition")) {
[17:28:18.282]                         if (!is.null(pattern)) {
[17:28:18.282]                           computeRestarts <- base::computeRestarts
[17:28:18.282]                           grepl <- base::grepl
[17:28:18.282]                           restarts <- computeRestarts(cond)
[17:28:18.282]                           for (restart in restarts) {
[17:28:18.282]                             name <- restart$name
[17:28:18.282]                             if (is.null(name)) 
[17:28:18.282]                               next
[17:28:18.282]                             if (!grepl(pattern, name)) 
[17:28:18.282]                               next
[17:28:18.282]                             invokeRestart(restart)
[17:28:18.282]                             muffled <- TRUE
[17:28:18.282]                             break
[17:28:18.282]                           }
[17:28:18.282]                         }
[17:28:18.282]                       }
[17:28:18.282]                       invisible(muffled)
[17:28:18.282]                     }
[17:28:18.282]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.282]                   }
[17:28:18.282]                 }
[17:28:18.282]             }
[17:28:18.282]         }))
[17:28:18.282]     }, error = function(ex) {
[17:28:18.282]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.282]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.282]                 ...future.rng), started = ...future.startTime, 
[17:28:18.282]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.282]             version = "1.8"), class = "FutureResult")
[17:28:18.282]     }, finally = {
[17:28:18.282]         if (!identical(...future.workdir, getwd())) 
[17:28:18.282]             setwd(...future.workdir)
[17:28:18.282]         {
[17:28:18.282]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.282]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.282]             }
[17:28:18.282]             base::options(...future.oldOptions)
[17:28:18.282]             if (.Platform$OS.type == "windows") {
[17:28:18.282]                 old_names <- names(...future.oldEnvVars)
[17:28:18.282]                 envs <- base::Sys.getenv()
[17:28:18.282]                 names <- names(envs)
[17:28:18.282]                 common <- intersect(names, old_names)
[17:28:18.282]                 added <- setdiff(names, old_names)
[17:28:18.282]                 removed <- setdiff(old_names, names)
[17:28:18.282]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.282]                   envs[common]]
[17:28:18.282]                 NAMES <- toupper(changed)
[17:28:18.282]                 args <- list()
[17:28:18.282]                 for (kk in seq_along(NAMES)) {
[17:28:18.282]                   name <- changed[[kk]]
[17:28:18.282]                   NAME <- NAMES[[kk]]
[17:28:18.282]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.282]                     next
[17:28:18.282]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.282]                 }
[17:28:18.282]                 NAMES <- toupper(added)
[17:28:18.282]                 for (kk in seq_along(NAMES)) {
[17:28:18.282]                   name <- added[[kk]]
[17:28:18.282]                   NAME <- NAMES[[kk]]
[17:28:18.282]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.282]                     next
[17:28:18.282]                   args[[name]] <- ""
[17:28:18.282]                 }
[17:28:18.282]                 NAMES <- toupper(removed)
[17:28:18.282]                 for (kk in seq_along(NAMES)) {
[17:28:18.282]                   name <- removed[[kk]]
[17:28:18.282]                   NAME <- NAMES[[kk]]
[17:28:18.282]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.282]                     next
[17:28:18.282]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.282]                 }
[17:28:18.282]                 if (length(args) > 0) 
[17:28:18.282]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.282]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.282]             }
[17:28:18.282]             else {
[17:28:18.282]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.282]             }
[17:28:18.282]             {
[17:28:18.282]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.282]                   0L) {
[17:28:18.282]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.282]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.282]                   base::options(opts)
[17:28:18.282]                 }
[17:28:18.282]                 {
[17:28:18.282]                   {
[17:28:18.282]                     base::assign(".Random.seed", c(10407L, 1544586554L, 
[17:28:18.282]                     -1109955828L, 235189556L, -1969451661L, -1276824933L, 
[17:28:18.282]                     -627630158L), envir = base::globalenv(), 
[17:28:18.282]                       inherits = FALSE)
[17:28:18.282]                     NULL
[17:28:18.282]                   }
[17:28:18.282]                   options(future.plan = NULL)
[17:28:18.282]                   if (is.na(NA_character_)) 
[17:28:18.282]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.282]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.282]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.282]                     .init = FALSE)
[17:28:18.282]                 }
[17:28:18.282]             }
[17:28:18.282]         }
[17:28:18.282]     })
[17:28:18.282]     if (TRUE) {
[17:28:18.282]         base::sink(type = "output", split = FALSE)
[17:28:18.282]         if (TRUE) {
[17:28:18.282]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.282]         }
[17:28:18.282]         else {
[17:28:18.282]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.282]         }
[17:28:18.282]         base::close(...future.stdout)
[17:28:18.282]         ...future.stdout <- NULL
[17:28:18.282]     }
[17:28:18.282]     ...future.result$conditions <- ...future.conditions
[17:28:18.282]     ...future.result$finished <- base::Sys.time()
[17:28:18.282]     ...future.result
[17:28:18.282] }
[17:28:18.285] assign_globals() ...
[17:28:18.285] List of 1
[17:28:18.285]  $ x: int [1:4] 0 1 2 3
[17:28:18.285]  - attr(*, "where")=List of 1
[17:28:18.285]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.285]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.285]  - attr(*, "resolved")= logi FALSE
[17:28:18.285]  - attr(*, "total_size")= num 64
[17:28:18.285]  - attr(*, "already-done")= logi TRUE
[17:28:18.289] - copied 'x' to environment
[17:28:18.289] assign_globals() ... done
[17:28:18.290] plan(): Setting new future strategy stack:
[17:28:18.290] List of future strategies:
[17:28:18.290] 1. sequential:
[17:28:18.290]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.290]    - tweaked: FALSE
[17:28:18.290]    - call: NULL
[17:28:18.291] plan(): nbrOfWorkers() = 1
[17:28:18.292] plan(): Setting new future strategy stack:
[17:28:18.292] List of future strategies:
[17:28:18.292] 1. sequential:
[17:28:18.292]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.292]    - tweaked: FALSE
[17:28:18.292]    - call: plan(strategy)
[17:28:18.293] plan(): nbrOfWorkers() = 1
[17:28:18.293] SequentialFuture started (and completed)
[17:28:18.293] - Launch lazy future ... done
[17:28:18.293] run() for 'SequentialFuture' ... done
[[1]]
[1] 1

[[2]]
[1] 1

[[3]]
[1] 2

[[4]]
[1] 2

[17:28:18.294] getGlobalsAndPackages() ...
[17:28:18.294] Searching for globals...
[17:28:18.296] - globals found: [3] '{', 'sample', 'x'
[17:28:18.296] Searching for globals ... DONE
[17:28:18.296] Resolving globals: FALSE
[17:28:18.297] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.297] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.297] - globals: [1] 'x'
[17:28:18.297] 
[17:28:18.298] getGlobalsAndPackages() ... DONE
[17:28:18.298] run() for 'Future' ...
[17:28:18.298] - state: 'created'
[17:28:18.298] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.299] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.299] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.299]   - Field: 'label'
[17:28:18.299]   - Field: 'local'
[17:28:18.299]   - Field: 'owner'
[17:28:18.299]   - Field: 'envir'
[17:28:18.300]   - Field: 'packages'
[17:28:18.300]   - Field: 'gc'
[17:28:18.300]   - Field: 'conditions'
[17:28:18.300]   - Field: 'expr'
[17:28:18.300]   - Field: 'uuid'
[17:28:18.300]   - Field: 'seed'
[17:28:18.301]   - Field: 'version'
[17:28:18.301]   - Field: 'result'
[17:28:18.301]   - Field: 'asynchronous'
[17:28:18.301]   - Field: 'calls'
[17:28:18.301]   - Field: 'globals'
[17:28:18.301]   - Field: 'stdout'
[17:28:18.302]   - Field: 'earlySignal'
[17:28:18.302]   - Field: 'lazy'
[17:28:18.302]   - Field: 'state'
[17:28:18.302] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.302] - Launch lazy future ...
[17:28:18.302] Packages needed by the future expression (n = 0): <none>
[17:28:18.303] Packages needed by future strategies (n = 0): <none>
[17:28:18.303] {
[17:28:18.303]     {
[17:28:18.303]         {
[17:28:18.303]             ...future.startTime <- base::Sys.time()
[17:28:18.303]             {
[17:28:18.303]                 {
[17:28:18.303]                   {
[17:28:18.303]                     base::local({
[17:28:18.303]                       has_future <- base::requireNamespace("future", 
[17:28:18.303]                         quietly = TRUE)
[17:28:18.303]                       if (has_future) {
[17:28:18.303]                         ns <- base::getNamespace("future")
[17:28:18.303]                         version <- ns[[".package"]][["version"]]
[17:28:18.303]                         if (is.null(version)) 
[17:28:18.303]                           version <- utils::packageVersion("future")
[17:28:18.303]                       }
[17:28:18.303]                       else {
[17:28:18.303]                         version <- NULL
[17:28:18.303]                       }
[17:28:18.303]                       if (!has_future || version < "1.8.0") {
[17:28:18.303]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.303]                           "", base::R.version$version.string), 
[17:28:18.303]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.303]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.303]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.303]                             "release", "version")], collapse = " "), 
[17:28:18.303]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.303]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.303]                           info)
[17:28:18.303]                         info <- base::paste(info, collapse = "; ")
[17:28:18.303]                         if (!has_future) {
[17:28:18.303]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.303]                             info)
[17:28:18.303]                         }
[17:28:18.303]                         else {
[17:28:18.303]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.303]                             info, version)
[17:28:18.303]                         }
[17:28:18.303]                         base::stop(msg)
[17:28:18.303]                       }
[17:28:18.303]                     })
[17:28:18.303]                   }
[17:28:18.303]                   ...future.strategy.old <- future::plan("list")
[17:28:18.303]                   options(future.plan = NULL)
[17:28:18.303]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.303]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.303]                 }
[17:28:18.303]                 ...future.workdir <- getwd()
[17:28:18.303]             }
[17:28:18.303]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.303]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.303]         }
[17:28:18.303]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.303]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.303]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.303]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.303]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.303]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.303]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.303]             base::names(...future.oldOptions))
[17:28:18.303]     }
[17:28:18.303]     if (FALSE) {
[17:28:18.303]     }
[17:28:18.303]     else {
[17:28:18.303]         if (TRUE) {
[17:28:18.303]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.303]                 open = "w")
[17:28:18.303]         }
[17:28:18.303]         else {
[17:28:18.303]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.303]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.303]         }
[17:28:18.303]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.303]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.303]             base::sink(type = "output", split = FALSE)
[17:28:18.303]             base::close(...future.stdout)
[17:28:18.303]         }, add = TRUE)
[17:28:18.303]     }
[17:28:18.303]     ...future.frame <- base::sys.nframe()
[17:28:18.303]     ...future.conditions <- base::list()
[17:28:18.303]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.303]     if (FALSE) {
[17:28:18.303]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.303]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.303]     }
[17:28:18.303]     ...future.result <- base::tryCatch({
[17:28:18.303]         base::withCallingHandlers({
[17:28:18.303]             ...future.value <- base::withVisible(base::local({
[17:28:18.303]                 sample(x, size = 1L)
[17:28:18.303]             }))
[17:28:18.303]             future::FutureResult(value = ...future.value$value, 
[17:28:18.303]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.303]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.303]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.303]                     ...future.globalenv.names))
[17:28:18.303]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.303]         }, condition = base::local({
[17:28:18.303]             c <- base::c
[17:28:18.303]             inherits <- base::inherits
[17:28:18.303]             invokeRestart <- base::invokeRestart
[17:28:18.303]             length <- base::length
[17:28:18.303]             list <- base::list
[17:28:18.303]             seq.int <- base::seq.int
[17:28:18.303]             signalCondition <- base::signalCondition
[17:28:18.303]             sys.calls <- base::sys.calls
[17:28:18.303]             `[[` <- base::`[[`
[17:28:18.303]             `+` <- base::`+`
[17:28:18.303]             `<<-` <- base::`<<-`
[17:28:18.303]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.303]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.303]                   3L)]
[17:28:18.303]             }
[17:28:18.303]             function(cond) {
[17:28:18.303]                 is_error <- inherits(cond, "error")
[17:28:18.303]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.303]                   NULL)
[17:28:18.303]                 if (is_error) {
[17:28:18.303]                   sessionInformation <- function() {
[17:28:18.303]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.303]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.303]                       search = base::search(), system = base::Sys.info())
[17:28:18.303]                   }
[17:28:18.303]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.303]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.303]                     cond$call), session = sessionInformation(), 
[17:28:18.303]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.303]                   signalCondition(cond)
[17:28:18.303]                 }
[17:28:18.303]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.303]                 "immediateCondition"))) {
[17:28:18.303]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.303]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.303]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.303]                   if (TRUE && !signal) {
[17:28:18.303]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.303]                     {
[17:28:18.303]                       inherits <- base::inherits
[17:28:18.303]                       invokeRestart <- base::invokeRestart
[17:28:18.303]                       is.null <- base::is.null
[17:28:18.303]                       muffled <- FALSE
[17:28:18.303]                       if (inherits(cond, "message")) {
[17:28:18.303]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.303]                         if (muffled) 
[17:28:18.303]                           invokeRestart("muffleMessage")
[17:28:18.303]                       }
[17:28:18.303]                       else if (inherits(cond, "warning")) {
[17:28:18.303]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.303]                         if (muffled) 
[17:28:18.303]                           invokeRestart("muffleWarning")
[17:28:18.303]                       }
[17:28:18.303]                       else if (inherits(cond, "condition")) {
[17:28:18.303]                         if (!is.null(pattern)) {
[17:28:18.303]                           computeRestarts <- base::computeRestarts
[17:28:18.303]                           grepl <- base::grepl
[17:28:18.303]                           restarts <- computeRestarts(cond)
[17:28:18.303]                           for (restart in restarts) {
[17:28:18.303]                             name <- restart$name
[17:28:18.303]                             if (is.null(name)) 
[17:28:18.303]                               next
[17:28:18.303]                             if (!grepl(pattern, name)) 
[17:28:18.303]                               next
[17:28:18.303]                             invokeRestart(restart)
[17:28:18.303]                             muffled <- TRUE
[17:28:18.303]                             break
[17:28:18.303]                           }
[17:28:18.303]                         }
[17:28:18.303]                       }
[17:28:18.303]                       invisible(muffled)
[17:28:18.303]                     }
[17:28:18.303]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.303]                   }
[17:28:18.303]                 }
[17:28:18.303]                 else {
[17:28:18.303]                   if (TRUE) {
[17:28:18.303]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.303]                     {
[17:28:18.303]                       inherits <- base::inherits
[17:28:18.303]                       invokeRestart <- base::invokeRestart
[17:28:18.303]                       is.null <- base::is.null
[17:28:18.303]                       muffled <- FALSE
[17:28:18.303]                       if (inherits(cond, "message")) {
[17:28:18.303]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.303]                         if (muffled) 
[17:28:18.303]                           invokeRestart("muffleMessage")
[17:28:18.303]                       }
[17:28:18.303]                       else if (inherits(cond, "warning")) {
[17:28:18.303]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.303]                         if (muffled) 
[17:28:18.303]                           invokeRestart("muffleWarning")
[17:28:18.303]                       }
[17:28:18.303]                       else if (inherits(cond, "condition")) {
[17:28:18.303]                         if (!is.null(pattern)) {
[17:28:18.303]                           computeRestarts <- base::computeRestarts
[17:28:18.303]                           grepl <- base::grepl
[17:28:18.303]                           restarts <- computeRestarts(cond)
[17:28:18.303]                           for (restart in restarts) {
[17:28:18.303]                             name <- restart$name
[17:28:18.303]                             if (is.null(name)) 
[17:28:18.303]                               next
[17:28:18.303]                             if (!grepl(pattern, name)) 
[17:28:18.303]                               next
[17:28:18.303]                             invokeRestart(restart)
[17:28:18.303]                             muffled <- TRUE
[17:28:18.303]                             break
[17:28:18.303]                           }
[17:28:18.303]                         }
[17:28:18.303]                       }
[17:28:18.303]                       invisible(muffled)
[17:28:18.303]                     }
[17:28:18.303]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.303]                   }
[17:28:18.303]                 }
[17:28:18.303]             }
[17:28:18.303]         }))
[17:28:18.303]     }, error = function(ex) {
[17:28:18.303]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.303]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.303]                 ...future.rng), started = ...future.startTime, 
[17:28:18.303]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.303]             version = "1.8"), class = "FutureResult")
[17:28:18.303]     }, finally = {
[17:28:18.303]         if (!identical(...future.workdir, getwd())) 
[17:28:18.303]             setwd(...future.workdir)
[17:28:18.303]         {
[17:28:18.303]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.303]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.303]             }
[17:28:18.303]             base::options(...future.oldOptions)
[17:28:18.303]             if (.Platform$OS.type == "windows") {
[17:28:18.303]                 old_names <- names(...future.oldEnvVars)
[17:28:18.303]                 envs <- base::Sys.getenv()
[17:28:18.303]                 names <- names(envs)
[17:28:18.303]                 common <- intersect(names, old_names)
[17:28:18.303]                 added <- setdiff(names, old_names)
[17:28:18.303]                 removed <- setdiff(old_names, names)
[17:28:18.303]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.303]                   envs[common]]
[17:28:18.303]                 NAMES <- toupper(changed)
[17:28:18.303]                 args <- list()
[17:28:18.303]                 for (kk in seq_along(NAMES)) {
[17:28:18.303]                   name <- changed[[kk]]
[17:28:18.303]                   NAME <- NAMES[[kk]]
[17:28:18.303]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.303]                     next
[17:28:18.303]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.303]                 }
[17:28:18.303]                 NAMES <- toupper(added)
[17:28:18.303]                 for (kk in seq_along(NAMES)) {
[17:28:18.303]                   name <- added[[kk]]
[17:28:18.303]                   NAME <- NAMES[[kk]]
[17:28:18.303]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.303]                     next
[17:28:18.303]                   args[[name]] <- ""
[17:28:18.303]                 }
[17:28:18.303]                 NAMES <- toupper(removed)
[17:28:18.303]                 for (kk in seq_along(NAMES)) {
[17:28:18.303]                   name <- removed[[kk]]
[17:28:18.303]                   NAME <- NAMES[[kk]]
[17:28:18.303]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.303]                     next
[17:28:18.303]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.303]                 }
[17:28:18.303]                 if (length(args) > 0) 
[17:28:18.303]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.303]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.303]             }
[17:28:18.303]             else {
[17:28:18.303]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.303]             }
[17:28:18.303]             {
[17:28:18.303]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.303]                   0L) {
[17:28:18.303]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.303]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.303]                   base::options(opts)
[17:28:18.303]                 }
[17:28:18.303]                 {
[17:28:18.303]                   {
[17:28:18.303]                     base::assign(".Random.seed", c(10407L, -1860205550L, 
[17:28:18.303]                     -13577262L, 1187492596L, 517537009L, 191770270L, 
[17:28:18.303]                     -952290750L), envir = base::globalenv(), 
[17:28:18.303]                       inherits = FALSE)
[17:28:18.303]                     NULL
[17:28:18.303]                   }
[17:28:18.303]                   options(future.plan = NULL)
[17:28:18.303]                   if (is.na(NA_character_)) 
[17:28:18.303]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.303]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.303]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.303]                     .init = FALSE)
[17:28:18.303]                 }
[17:28:18.303]             }
[17:28:18.303]         }
[17:28:18.303]     })
[17:28:18.303]     if (TRUE) {
[17:28:18.303]         base::sink(type = "output", split = FALSE)
[17:28:18.303]         if (TRUE) {
[17:28:18.303]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.303]         }
[17:28:18.303]         else {
[17:28:18.303]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.303]         }
[17:28:18.303]         base::close(...future.stdout)
[17:28:18.303]         ...future.stdout <- NULL
[17:28:18.303]     }
[17:28:18.303]     ...future.result$conditions <- ...future.conditions
[17:28:18.303]     ...future.result$finished <- base::Sys.time()
[17:28:18.303]     ...future.result
[17:28:18.303] }
[17:28:18.307] assign_globals() ...
[17:28:18.307] List of 1
[17:28:18.307]  $ x: int [1:4] 0 1 2 3
[17:28:18.307]  - attr(*, "where")=List of 1
[17:28:18.307]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.307]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.307]  - attr(*, "resolved")= logi FALSE
[17:28:18.307]  - attr(*, "total_size")= num 64
[17:28:18.307]  - attr(*, "already-done")= logi TRUE
[17:28:18.310] - copied 'x' to environment
[17:28:18.310] assign_globals() ... done
[17:28:18.310] plan(): Setting new future strategy stack:
[17:28:18.310] List of future strategies:
[17:28:18.310] 1. sequential:
[17:28:18.310]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.310]    - tweaked: FALSE
[17:28:18.310]    - call: NULL
[17:28:18.311] plan(): nbrOfWorkers() = 1
[17:28:18.312] plan(): Setting new future strategy stack:
[17:28:18.312] List of future strategies:
[17:28:18.312] 1. sequential:
[17:28:18.312]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.312]    - tweaked: FALSE
[17:28:18.312]    - call: plan(strategy)
[17:28:18.313] plan(): nbrOfWorkers() = 1
[17:28:18.313] SequentialFuture started (and completed)
[17:28:18.313] - Launch lazy future ... done
[17:28:18.314] run() for 'SequentialFuture' ... done
[17:28:18.314] getGlobalsAndPackages() ...
[17:28:18.314] Searching for globals...
[17:28:18.316] - globals found: [3] '{', 'sample', 'x'
[17:28:18.316] Searching for globals ... DONE
[17:28:18.316] Resolving globals: FALSE
[17:28:18.316] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.317] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.317] - globals: [1] 'x'
[17:28:18.318] 
[17:28:18.318] getGlobalsAndPackages() ... DONE
[17:28:18.319] run() for 'Future' ...
[17:28:18.319] - state: 'created'
[17:28:18.319] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.319] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.320] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.320]   - Field: 'label'
[17:28:18.320]   - Field: 'local'
[17:28:18.320]   - Field: 'owner'
[17:28:18.320]   - Field: 'envir'
[17:28:18.321]   - Field: 'packages'
[17:28:18.321]   - Field: 'gc'
[17:28:18.321]   - Field: 'conditions'
[17:28:18.321]   - Field: 'expr'
[17:28:18.321]   - Field: 'uuid'
[17:28:18.321]   - Field: 'seed'
[17:28:18.322]   - Field: 'version'
[17:28:18.322]   - Field: 'result'
[17:28:18.322]   - Field: 'asynchronous'
[17:28:18.322]   - Field: 'calls'
[17:28:18.322]   - Field: 'globals'
[17:28:18.322]   - Field: 'stdout'
[17:28:18.323]   - Field: 'earlySignal'
[17:28:18.323]   - Field: 'lazy'
[17:28:18.323]   - Field: 'state'
[17:28:18.323] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.323] - Launch lazy future ...
[17:28:18.324] Packages needed by the future expression (n = 0): <none>
[17:28:18.324] Packages needed by future strategies (n = 0): <none>
[17:28:18.324] {
[17:28:18.324]     {
[17:28:18.324]         {
[17:28:18.324]             ...future.startTime <- base::Sys.time()
[17:28:18.324]             {
[17:28:18.324]                 {
[17:28:18.324]                   {
[17:28:18.324]                     base::local({
[17:28:18.324]                       has_future <- base::requireNamespace("future", 
[17:28:18.324]                         quietly = TRUE)
[17:28:18.324]                       if (has_future) {
[17:28:18.324]                         ns <- base::getNamespace("future")
[17:28:18.324]                         version <- ns[[".package"]][["version"]]
[17:28:18.324]                         if (is.null(version)) 
[17:28:18.324]                           version <- utils::packageVersion("future")
[17:28:18.324]                       }
[17:28:18.324]                       else {
[17:28:18.324]                         version <- NULL
[17:28:18.324]                       }
[17:28:18.324]                       if (!has_future || version < "1.8.0") {
[17:28:18.324]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.324]                           "", base::R.version$version.string), 
[17:28:18.324]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.324]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.324]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.324]                             "release", "version")], collapse = " "), 
[17:28:18.324]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.324]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.324]                           info)
[17:28:18.324]                         info <- base::paste(info, collapse = "; ")
[17:28:18.324]                         if (!has_future) {
[17:28:18.324]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.324]                             info)
[17:28:18.324]                         }
[17:28:18.324]                         else {
[17:28:18.324]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.324]                             info, version)
[17:28:18.324]                         }
[17:28:18.324]                         base::stop(msg)
[17:28:18.324]                       }
[17:28:18.324]                     })
[17:28:18.324]                   }
[17:28:18.324]                   ...future.strategy.old <- future::plan("list")
[17:28:18.324]                   options(future.plan = NULL)
[17:28:18.324]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.324]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.324]                 }
[17:28:18.324]                 ...future.workdir <- getwd()
[17:28:18.324]             }
[17:28:18.324]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.324]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.324]         }
[17:28:18.324]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.324]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.324]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.324]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.324]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.324]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.324]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.324]             base::names(...future.oldOptions))
[17:28:18.324]     }
[17:28:18.324]     if (FALSE) {
[17:28:18.324]     }
[17:28:18.324]     else {
[17:28:18.324]         if (TRUE) {
[17:28:18.324]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.324]                 open = "w")
[17:28:18.324]         }
[17:28:18.324]         else {
[17:28:18.324]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.324]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.324]         }
[17:28:18.324]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.324]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.324]             base::sink(type = "output", split = FALSE)
[17:28:18.324]             base::close(...future.stdout)
[17:28:18.324]         }, add = TRUE)
[17:28:18.324]     }
[17:28:18.324]     ...future.frame <- base::sys.nframe()
[17:28:18.324]     ...future.conditions <- base::list()
[17:28:18.324]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.324]     if (FALSE) {
[17:28:18.324]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.324]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.324]     }
[17:28:18.324]     ...future.result <- base::tryCatch({
[17:28:18.324]         base::withCallingHandlers({
[17:28:18.324]             ...future.value <- base::withVisible(base::local({
[17:28:18.324]                 sample(x, size = 1L)
[17:28:18.324]             }))
[17:28:18.324]             future::FutureResult(value = ...future.value$value, 
[17:28:18.324]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.324]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.324]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.324]                     ...future.globalenv.names))
[17:28:18.324]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.324]         }, condition = base::local({
[17:28:18.324]             c <- base::c
[17:28:18.324]             inherits <- base::inherits
[17:28:18.324]             invokeRestart <- base::invokeRestart
[17:28:18.324]             length <- base::length
[17:28:18.324]             list <- base::list
[17:28:18.324]             seq.int <- base::seq.int
[17:28:18.324]             signalCondition <- base::signalCondition
[17:28:18.324]             sys.calls <- base::sys.calls
[17:28:18.324]             `[[` <- base::`[[`
[17:28:18.324]             `+` <- base::`+`
[17:28:18.324]             `<<-` <- base::`<<-`
[17:28:18.324]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.324]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.324]                   3L)]
[17:28:18.324]             }
[17:28:18.324]             function(cond) {
[17:28:18.324]                 is_error <- inherits(cond, "error")
[17:28:18.324]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.324]                   NULL)
[17:28:18.324]                 if (is_error) {
[17:28:18.324]                   sessionInformation <- function() {
[17:28:18.324]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.324]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.324]                       search = base::search(), system = base::Sys.info())
[17:28:18.324]                   }
[17:28:18.324]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.324]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.324]                     cond$call), session = sessionInformation(), 
[17:28:18.324]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.324]                   signalCondition(cond)
[17:28:18.324]                 }
[17:28:18.324]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.324]                 "immediateCondition"))) {
[17:28:18.324]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.324]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.324]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.324]                   if (TRUE && !signal) {
[17:28:18.324]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.324]                     {
[17:28:18.324]                       inherits <- base::inherits
[17:28:18.324]                       invokeRestart <- base::invokeRestart
[17:28:18.324]                       is.null <- base::is.null
[17:28:18.324]                       muffled <- FALSE
[17:28:18.324]                       if (inherits(cond, "message")) {
[17:28:18.324]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.324]                         if (muffled) 
[17:28:18.324]                           invokeRestart("muffleMessage")
[17:28:18.324]                       }
[17:28:18.324]                       else if (inherits(cond, "warning")) {
[17:28:18.324]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.324]                         if (muffled) 
[17:28:18.324]                           invokeRestart("muffleWarning")
[17:28:18.324]                       }
[17:28:18.324]                       else if (inherits(cond, "condition")) {
[17:28:18.324]                         if (!is.null(pattern)) {
[17:28:18.324]                           computeRestarts <- base::computeRestarts
[17:28:18.324]                           grepl <- base::grepl
[17:28:18.324]                           restarts <- computeRestarts(cond)
[17:28:18.324]                           for (restart in restarts) {
[17:28:18.324]                             name <- restart$name
[17:28:18.324]                             if (is.null(name)) 
[17:28:18.324]                               next
[17:28:18.324]                             if (!grepl(pattern, name)) 
[17:28:18.324]                               next
[17:28:18.324]                             invokeRestart(restart)
[17:28:18.324]                             muffled <- TRUE
[17:28:18.324]                             break
[17:28:18.324]                           }
[17:28:18.324]                         }
[17:28:18.324]                       }
[17:28:18.324]                       invisible(muffled)
[17:28:18.324]                     }
[17:28:18.324]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.324]                   }
[17:28:18.324]                 }
[17:28:18.324]                 else {
[17:28:18.324]                   if (TRUE) {
[17:28:18.324]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.324]                     {
[17:28:18.324]                       inherits <- base::inherits
[17:28:18.324]                       invokeRestart <- base::invokeRestart
[17:28:18.324]                       is.null <- base::is.null
[17:28:18.324]                       muffled <- FALSE
[17:28:18.324]                       if (inherits(cond, "message")) {
[17:28:18.324]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.324]                         if (muffled) 
[17:28:18.324]                           invokeRestart("muffleMessage")
[17:28:18.324]                       }
[17:28:18.324]                       else if (inherits(cond, "warning")) {
[17:28:18.324]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.324]                         if (muffled) 
[17:28:18.324]                           invokeRestart("muffleWarning")
[17:28:18.324]                       }
[17:28:18.324]                       else if (inherits(cond, "condition")) {
[17:28:18.324]                         if (!is.null(pattern)) {
[17:28:18.324]                           computeRestarts <- base::computeRestarts
[17:28:18.324]                           grepl <- base::grepl
[17:28:18.324]                           restarts <- computeRestarts(cond)
[17:28:18.324]                           for (restart in restarts) {
[17:28:18.324]                             name <- restart$name
[17:28:18.324]                             if (is.null(name)) 
[17:28:18.324]                               next
[17:28:18.324]                             if (!grepl(pattern, name)) 
[17:28:18.324]                               next
[17:28:18.324]                             invokeRestart(restart)
[17:28:18.324]                             muffled <- TRUE
[17:28:18.324]                             break
[17:28:18.324]                           }
[17:28:18.324]                         }
[17:28:18.324]                       }
[17:28:18.324]                       invisible(muffled)
[17:28:18.324]                     }
[17:28:18.324]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.324]                   }
[17:28:18.324]                 }
[17:28:18.324]             }
[17:28:18.324]         }))
[17:28:18.324]     }, error = function(ex) {
[17:28:18.324]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.324]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.324]                 ...future.rng), started = ...future.startTime, 
[17:28:18.324]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.324]             version = "1.8"), class = "FutureResult")
[17:28:18.324]     }, finally = {
[17:28:18.324]         if (!identical(...future.workdir, getwd())) 
[17:28:18.324]             setwd(...future.workdir)
[17:28:18.324]         {
[17:28:18.324]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.324]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.324]             }
[17:28:18.324]             base::options(...future.oldOptions)
[17:28:18.324]             if (.Platform$OS.type == "windows") {
[17:28:18.324]                 old_names <- names(...future.oldEnvVars)
[17:28:18.324]                 envs <- base::Sys.getenv()
[17:28:18.324]                 names <- names(envs)
[17:28:18.324]                 common <- intersect(names, old_names)
[17:28:18.324]                 added <- setdiff(names, old_names)
[17:28:18.324]                 removed <- setdiff(old_names, names)
[17:28:18.324]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.324]                   envs[common]]
[17:28:18.324]                 NAMES <- toupper(changed)
[17:28:18.324]                 args <- list()
[17:28:18.324]                 for (kk in seq_along(NAMES)) {
[17:28:18.324]                   name <- changed[[kk]]
[17:28:18.324]                   NAME <- NAMES[[kk]]
[17:28:18.324]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.324]                     next
[17:28:18.324]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.324]                 }
[17:28:18.324]                 NAMES <- toupper(added)
[17:28:18.324]                 for (kk in seq_along(NAMES)) {
[17:28:18.324]                   name <- added[[kk]]
[17:28:18.324]                   NAME <- NAMES[[kk]]
[17:28:18.324]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.324]                     next
[17:28:18.324]                   args[[name]] <- ""
[17:28:18.324]                 }
[17:28:18.324]                 NAMES <- toupper(removed)
[17:28:18.324]                 for (kk in seq_along(NAMES)) {
[17:28:18.324]                   name <- removed[[kk]]
[17:28:18.324]                   NAME <- NAMES[[kk]]
[17:28:18.324]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.324]                     next
[17:28:18.324]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.324]                 }
[17:28:18.324]                 if (length(args) > 0) 
[17:28:18.324]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.324]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.324]             }
[17:28:18.324]             else {
[17:28:18.324]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.324]             }
[17:28:18.324]             {
[17:28:18.324]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.324]                   0L) {
[17:28:18.324]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.324]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.324]                   base::options(opts)
[17:28:18.324]                 }
[17:28:18.324]                 {
[17:28:18.324]                   {
[17:28:18.324]                     base::assign(".Random.seed", c(10407L, 1187492596L, 
[17:28:18.324]                     -1013414601L, 866756367L, -952290750L, -55952870L, 
[17:28:18.324]                     707627690L), envir = base::globalenv(), inherits = FALSE)
[17:28:18.324]                     NULL
[17:28:18.324]                   }
[17:28:18.324]                   options(future.plan = NULL)
[17:28:18.324]                   if (is.na(NA_character_)) 
[17:28:18.324]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.324]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.324]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.324]                     .init = FALSE)
[17:28:18.324]                 }
[17:28:18.324]             }
[17:28:18.324]         }
[17:28:18.324]     })
[17:28:18.324]     if (TRUE) {
[17:28:18.324]         base::sink(type = "output", split = FALSE)
[17:28:18.324]         if (TRUE) {
[17:28:18.324]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.324]         }
[17:28:18.324]         else {
[17:28:18.324]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.324]         }
[17:28:18.324]         base::close(...future.stdout)
[17:28:18.324]         ...future.stdout <- NULL
[17:28:18.324]     }
[17:28:18.324]     ...future.result$conditions <- ...future.conditions
[17:28:18.324]     ...future.result$finished <- base::Sys.time()
[17:28:18.324]     ...future.result
[17:28:18.324] }
[17:28:18.328] assign_globals() ...
[17:28:18.328] List of 1
[17:28:18.328]  $ x: int [1:4] 0 1 2 3
[17:28:18.328]  - attr(*, "where")=List of 1
[17:28:18.328]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.328]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.328]  - attr(*, "resolved")= logi FALSE
[17:28:18.328]  - attr(*, "total_size")= num 64
[17:28:18.328]  - attr(*, "already-done")= logi TRUE
[17:28:18.331] - copied 'x' to environment
[17:28:18.331] assign_globals() ... done
[17:28:18.332] plan(): Setting new future strategy stack:
[17:28:18.332] List of future strategies:
[17:28:18.332] 1. sequential:
[17:28:18.332]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.332]    - tweaked: FALSE
[17:28:18.332]    - call: NULL
[17:28:18.332] plan(): nbrOfWorkers() = 1
[17:28:18.334] plan(): Setting new future strategy stack:
[17:28:18.334] List of future strategies:
[17:28:18.334] 1. sequential:
[17:28:18.334]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.334]    - tweaked: FALSE
[17:28:18.334]    - call: plan(strategy)
[17:28:18.334] plan(): nbrOfWorkers() = 1
[17:28:18.335] SequentialFuture started (and completed)
[17:28:18.335] - Launch lazy future ... done
[17:28:18.335] run() for 'SequentialFuture' ... done
[17:28:18.335] getGlobalsAndPackages() ...
[17:28:18.336] Searching for globals...
[17:28:18.337] - globals found: [3] '{', 'sample', 'x'
[17:28:18.337] Searching for globals ... DONE
[17:28:18.337] Resolving globals: FALSE
[17:28:18.338] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.338] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.338] - globals: [1] 'x'
[17:28:18.338] 
[17:28:18.339] getGlobalsAndPackages() ... DONE
[17:28:18.339] run() for 'Future' ...
[17:28:18.339] - state: 'created'
[17:28:18.339] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.340] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.340] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.340]   - Field: 'label'
[17:28:18.340]   - Field: 'local'
[17:28:18.340]   - Field: 'owner'
[17:28:18.341]   - Field: 'envir'
[17:28:18.341]   - Field: 'packages'
[17:28:18.341]   - Field: 'gc'
[17:28:18.341]   - Field: 'conditions'
[17:28:18.341]   - Field: 'expr'
[17:28:18.341]   - Field: 'uuid'
[17:28:18.342]   - Field: 'seed'
[17:28:18.342]   - Field: 'version'
[17:28:18.342]   - Field: 'result'
[17:28:18.342]   - Field: 'asynchronous'
[17:28:18.342]   - Field: 'calls'
[17:28:18.342]   - Field: 'globals'
[17:28:18.343]   - Field: 'stdout'
[17:28:18.343]   - Field: 'earlySignal'
[17:28:18.343]   - Field: 'lazy'
[17:28:18.343]   - Field: 'state'
[17:28:18.343] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.344] - Launch lazy future ...
[17:28:18.344] Packages needed by the future expression (n = 0): <none>
[17:28:18.344] Packages needed by future strategies (n = 0): <none>
[17:28:18.345] {
[17:28:18.345]     {
[17:28:18.345]         {
[17:28:18.345]             ...future.startTime <- base::Sys.time()
[17:28:18.345]             {
[17:28:18.345]                 {
[17:28:18.345]                   {
[17:28:18.345]                     base::local({
[17:28:18.345]                       has_future <- base::requireNamespace("future", 
[17:28:18.345]                         quietly = TRUE)
[17:28:18.345]                       if (has_future) {
[17:28:18.345]                         ns <- base::getNamespace("future")
[17:28:18.345]                         version <- ns[[".package"]][["version"]]
[17:28:18.345]                         if (is.null(version)) 
[17:28:18.345]                           version <- utils::packageVersion("future")
[17:28:18.345]                       }
[17:28:18.345]                       else {
[17:28:18.345]                         version <- NULL
[17:28:18.345]                       }
[17:28:18.345]                       if (!has_future || version < "1.8.0") {
[17:28:18.345]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.345]                           "", base::R.version$version.string), 
[17:28:18.345]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.345]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.345]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.345]                             "release", "version")], collapse = " "), 
[17:28:18.345]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.345]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.345]                           info)
[17:28:18.345]                         info <- base::paste(info, collapse = "; ")
[17:28:18.345]                         if (!has_future) {
[17:28:18.345]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.345]                             info)
[17:28:18.345]                         }
[17:28:18.345]                         else {
[17:28:18.345]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.345]                             info, version)
[17:28:18.345]                         }
[17:28:18.345]                         base::stop(msg)
[17:28:18.345]                       }
[17:28:18.345]                     })
[17:28:18.345]                   }
[17:28:18.345]                   ...future.strategy.old <- future::plan("list")
[17:28:18.345]                   options(future.plan = NULL)
[17:28:18.345]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.345]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.345]                 }
[17:28:18.345]                 ...future.workdir <- getwd()
[17:28:18.345]             }
[17:28:18.345]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.345]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.345]         }
[17:28:18.345]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.345]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.345]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.345]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.345]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.345]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.345]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.345]             base::names(...future.oldOptions))
[17:28:18.345]     }
[17:28:18.345]     if (FALSE) {
[17:28:18.345]     }
[17:28:18.345]     else {
[17:28:18.345]         if (TRUE) {
[17:28:18.345]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.345]                 open = "w")
[17:28:18.345]         }
[17:28:18.345]         else {
[17:28:18.345]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.345]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.345]         }
[17:28:18.345]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.345]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.345]             base::sink(type = "output", split = FALSE)
[17:28:18.345]             base::close(...future.stdout)
[17:28:18.345]         }, add = TRUE)
[17:28:18.345]     }
[17:28:18.345]     ...future.frame <- base::sys.nframe()
[17:28:18.345]     ...future.conditions <- base::list()
[17:28:18.345]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.345]     if (FALSE) {
[17:28:18.345]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.345]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.345]     }
[17:28:18.345]     ...future.result <- base::tryCatch({
[17:28:18.345]         base::withCallingHandlers({
[17:28:18.345]             ...future.value <- base::withVisible(base::local({
[17:28:18.345]                 sample(x, size = 1L)
[17:28:18.345]             }))
[17:28:18.345]             future::FutureResult(value = ...future.value$value, 
[17:28:18.345]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.345]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.345]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.345]                     ...future.globalenv.names))
[17:28:18.345]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.345]         }, condition = base::local({
[17:28:18.345]             c <- base::c
[17:28:18.345]             inherits <- base::inherits
[17:28:18.345]             invokeRestart <- base::invokeRestart
[17:28:18.345]             length <- base::length
[17:28:18.345]             list <- base::list
[17:28:18.345]             seq.int <- base::seq.int
[17:28:18.345]             signalCondition <- base::signalCondition
[17:28:18.345]             sys.calls <- base::sys.calls
[17:28:18.345]             `[[` <- base::`[[`
[17:28:18.345]             `+` <- base::`+`
[17:28:18.345]             `<<-` <- base::`<<-`
[17:28:18.345]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.345]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.345]                   3L)]
[17:28:18.345]             }
[17:28:18.345]             function(cond) {
[17:28:18.345]                 is_error <- inherits(cond, "error")
[17:28:18.345]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.345]                   NULL)
[17:28:18.345]                 if (is_error) {
[17:28:18.345]                   sessionInformation <- function() {
[17:28:18.345]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.345]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.345]                       search = base::search(), system = base::Sys.info())
[17:28:18.345]                   }
[17:28:18.345]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.345]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.345]                     cond$call), session = sessionInformation(), 
[17:28:18.345]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.345]                   signalCondition(cond)
[17:28:18.345]                 }
[17:28:18.345]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.345]                 "immediateCondition"))) {
[17:28:18.345]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.345]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.345]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.345]                   if (TRUE && !signal) {
[17:28:18.345]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.345]                     {
[17:28:18.345]                       inherits <- base::inherits
[17:28:18.345]                       invokeRestart <- base::invokeRestart
[17:28:18.345]                       is.null <- base::is.null
[17:28:18.345]                       muffled <- FALSE
[17:28:18.345]                       if (inherits(cond, "message")) {
[17:28:18.345]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.345]                         if (muffled) 
[17:28:18.345]                           invokeRestart("muffleMessage")
[17:28:18.345]                       }
[17:28:18.345]                       else if (inherits(cond, "warning")) {
[17:28:18.345]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.345]                         if (muffled) 
[17:28:18.345]                           invokeRestart("muffleWarning")
[17:28:18.345]                       }
[17:28:18.345]                       else if (inherits(cond, "condition")) {
[17:28:18.345]                         if (!is.null(pattern)) {
[17:28:18.345]                           computeRestarts <- base::computeRestarts
[17:28:18.345]                           grepl <- base::grepl
[17:28:18.345]                           restarts <- computeRestarts(cond)
[17:28:18.345]                           for (restart in restarts) {
[17:28:18.345]                             name <- restart$name
[17:28:18.345]                             if (is.null(name)) 
[17:28:18.345]                               next
[17:28:18.345]                             if (!grepl(pattern, name)) 
[17:28:18.345]                               next
[17:28:18.345]                             invokeRestart(restart)
[17:28:18.345]                             muffled <- TRUE
[17:28:18.345]                             break
[17:28:18.345]                           }
[17:28:18.345]                         }
[17:28:18.345]                       }
[17:28:18.345]                       invisible(muffled)
[17:28:18.345]                     }
[17:28:18.345]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.345]                   }
[17:28:18.345]                 }
[17:28:18.345]                 else {
[17:28:18.345]                   if (TRUE) {
[17:28:18.345]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.345]                     {
[17:28:18.345]                       inherits <- base::inherits
[17:28:18.345]                       invokeRestart <- base::invokeRestart
[17:28:18.345]                       is.null <- base::is.null
[17:28:18.345]                       muffled <- FALSE
[17:28:18.345]                       if (inherits(cond, "message")) {
[17:28:18.345]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.345]                         if (muffled) 
[17:28:18.345]                           invokeRestart("muffleMessage")
[17:28:18.345]                       }
[17:28:18.345]                       else if (inherits(cond, "warning")) {
[17:28:18.345]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.345]                         if (muffled) 
[17:28:18.345]                           invokeRestart("muffleWarning")
[17:28:18.345]                       }
[17:28:18.345]                       else if (inherits(cond, "condition")) {
[17:28:18.345]                         if (!is.null(pattern)) {
[17:28:18.345]                           computeRestarts <- base::computeRestarts
[17:28:18.345]                           grepl <- base::grepl
[17:28:18.345]                           restarts <- computeRestarts(cond)
[17:28:18.345]                           for (restart in restarts) {
[17:28:18.345]                             name <- restart$name
[17:28:18.345]                             if (is.null(name)) 
[17:28:18.345]                               next
[17:28:18.345]                             if (!grepl(pattern, name)) 
[17:28:18.345]                               next
[17:28:18.345]                             invokeRestart(restart)
[17:28:18.345]                             muffled <- TRUE
[17:28:18.345]                             break
[17:28:18.345]                           }
[17:28:18.345]                         }
[17:28:18.345]                       }
[17:28:18.345]                       invisible(muffled)
[17:28:18.345]                     }
[17:28:18.345]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.345]                   }
[17:28:18.345]                 }
[17:28:18.345]             }
[17:28:18.345]         }))
[17:28:18.345]     }, error = function(ex) {
[17:28:18.345]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.345]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.345]                 ...future.rng), started = ...future.startTime, 
[17:28:18.345]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.345]             version = "1.8"), class = "FutureResult")
[17:28:18.345]     }, finally = {
[17:28:18.345]         if (!identical(...future.workdir, getwd())) 
[17:28:18.345]             setwd(...future.workdir)
[17:28:18.345]         {
[17:28:18.345]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.345]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.345]             }
[17:28:18.345]             base::options(...future.oldOptions)
[17:28:18.345]             if (.Platform$OS.type == "windows") {
[17:28:18.345]                 old_names <- names(...future.oldEnvVars)
[17:28:18.345]                 envs <- base::Sys.getenv()
[17:28:18.345]                 names <- names(envs)
[17:28:18.345]                 common <- intersect(names, old_names)
[17:28:18.345]                 added <- setdiff(names, old_names)
[17:28:18.345]                 removed <- setdiff(old_names, names)
[17:28:18.345]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.345]                   envs[common]]
[17:28:18.345]                 NAMES <- toupper(changed)
[17:28:18.345]                 args <- list()
[17:28:18.345]                 for (kk in seq_along(NAMES)) {
[17:28:18.345]                   name <- changed[[kk]]
[17:28:18.345]                   NAME <- NAMES[[kk]]
[17:28:18.345]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.345]                     next
[17:28:18.345]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.345]                 }
[17:28:18.345]                 NAMES <- toupper(added)
[17:28:18.345]                 for (kk in seq_along(NAMES)) {
[17:28:18.345]                   name <- added[[kk]]
[17:28:18.345]                   NAME <- NAMES[[kk]]
[17:28:18.345]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.345]                     next
[17:28:18.345]                   args[[name]] <- ""
[17:28:18.345]                 }
[17:28:18.345]                 NAMES <- toupper(removed)
[17:28:18.345]                 for (kk in seq_along(NAMES)) {
[17:28:18.345]                   name <- removed[[kk]]
[17:28:18.345]                   NAME <- NAMES[[kk]]
[17:28:18.345]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.345]                     next
[17:28:18.345]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.345]                 }
[17:28:18.345]                 if (length(args) > 0) 
[17:28:18.345]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.345]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.345]             }
[17:28:18.345]             else {
[17:28:18.345]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.345]             }
[17:28:18.345]             {
[17:28:18.345]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.345]                   0L) {
[17:28:18.345]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.345]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.345]                   base::options(opts)
[17:28:18.345]                 }
[17:28:18.345]                 {
[17:28:18.345]                   {
[17:28:18.345]                     base::assign(".Random.seed", c(10407L, 866756367L, 
[17:28:18.345]                     -417401399L, 1578556647L, 707627690L, 642855454L, 
[17:28:18.345]                     -1203128252L), envir = base::globalenv(), 
[17:28:18.345]                       inherits = FALSE)
[17:28:18.345]                     NULL
[17:28:18.345]                   }
[17:28:18.345]                   options(future.plan = NULL)
[17:28:18.345]                   if (is.na(NA_character_)) 
[17:28:18.345]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.345]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.345]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.345]                     .init = FALSE)
[17:28:18.345]                 }
[17:28:18.345]             }
[17:28:18.345]         }
[17:28:18.345]     })
[17:28:18.345]     if (TRUE) {
[17:28:18.345]         base::sink(type = "output", split = FALSE)
[17:28:18.345]         if (TRUE) {
[17:28:18.345]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.345]         }
[17:28:18.345]         else {
[17:28:18.345]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.345]         }
[17:28:18.345]         base::close(...future.stdout)
[17:28:18.345]         ...future.stdout <- NULL
[17:28:18.345]     }
[17:28:18.345]     ...future.result$conditions <- ...future.conditions
[17:28:18.345]     ...future.result$finished <- base::Sys.time()
[17:28:18.345]     ...future.result
[17:28:18.345] }
[17:28:18.349] assign_globals() ...
[17:28:18.349] List of 1
[17:28:18.349]  $ x: int [1:4] 0 1 2 3
[17:28:18.349]  - attr(*, "where")=List of 1
[17:28:18.349]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.349]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.349]  - attr(*, "resolved")= logi FALSE
[17:28:18.349]  - attr(*, "total_size")= num 64
[17:28:18.349]  - attr(*, "already-done")= logi TRUE
[17:28:18.354] - copied 'x' to environment
[17:28:18.354] assign_globals() ... done
[17:28:18.355] plan(): Setting new future strategy stack:
[17:28:18.355] List of future strategies:
[17:28:18.355] 1. sequential:
[17:28:18.355]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.355]    - tweaked: FALSE
[17:28:18.355]    - call: NULL
[17:28:18.356] plan(): nbrOfWorkers() = 1
[17:28:18.357] plan(): Setting new future strategy stack:
[17:28:18.357] List of future strategies:
[17:28:18.357] 1. sequential:
[17:28:18.357]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.357]    - tweaked: FALSE
[17:28:18.357]    - call: plan(strategy)
[17:28:18.358] plan(): nbrOfWorkers() = 1
[17:28:18.358] SequentialFuture started (and completed)
[17:28:18.358] - Launch lazy future ... done
[17:28:18.359] run() for 'SequentialFuture' ... done
[17:28:18.359] getGlobalsAndPackages() ...
[17:28:18.360] Searching for globals...
[17:28:18.361] - globals found: [3] '{', 'sample', 'x'
[17:28:18.361] Searching for globals ... DONE
[17:28:18.361] Resolving globals: FALSE
[17:28:18.362] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.362] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.363] - globals: [1] 'x'
[17:28:18.363] 
[17:28:18.363] getGlobalsAndPackages() ... DONE
[17:28:18.363] run() for 'Future' ...
[17:28:18.364] - state: 'created'
[17:28:18.364] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.364] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.365] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.365]   - Field: 'label'
[17:28:18.365]   - Field: 'local'
[17:28:18.365]   - Field: 'owner'
[17:28:18.365]   - Field: 'envir'
[17:28:18.366]   - Field: 'packages'
[17:28:18.366]   - Field: 'gc'
[17:28:18.366]   - Field: 'conditions'
[17:28:18.366]   - Field: 'expr'
[17:28:18.366]   - Field: 'uuid'
[17:28:18.366]   - Field: 'seed'
[17:28:18.367]   - Field: 'version'
[17:28:18.367]   - Field: 'result'
[17:28:18.367]   - Field: 'asynchronous'
[17:28:18.367]   - Field: 'calls'
[17:28:18.367]   - Field: 'globals'
[17:28:18.367]   - Field: 'stdout'
[17:28:18.368]   - Field: 'earlySignal'
[17:28:18.368]   - Field: 'lazy'
[17:28:18.368]   - Field: 'state'
[17:28:18.368] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.368] - Launch lazy future ...
[17:28:18.369] Packages needed by the future expression (n = 0): <none>
[17:28:18.369] Packages needed by future strategies (n = 0): <none>
[17:28:18.369] {
[17:28:18.369]     {
[17:28:18.369]         {
[17:28:18.369]             ...future.startTime <- base::Sys.time()
[17:28:18.369]             {
[17:28:18.369]                 {
[17:28:18.369]                   {
[17:28:18.369]                     base::local({
[17:28:18.369]                       has_future <- base::requireNamespace("future", 
[17:28:18.369]                         quietly = TRUE)
[17:28:18.369]                       if (has_future) {
[17:28:18.369]                         ns <- base::getNamespace("future")
[17:28:18.369]                         version <- ns[[".package"]][["version"]]
[17:28:18.369]                         if (is.null(version)) 
[17:28:18.369]                           version <- utils::packageVersion("future")
[17:28:18.369]                       }
[17:28:18.369]                       else {
[17:28:18.369]                         version <- NULL
[17:28:18.369]                       }
[17:28:18.369]                       if (!has_future || version < "1.8.0") {
[17:28:18.369]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.369]                           "", base::R.version$version.string), 
[17:28:18.369]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.369]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.369]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.369]                             "release", "version")], collapse = " "), 
[17:28:18.369]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.369]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.369]                           info)
[17:28:18.369]                         info <- base::paste(info, collapse = "; ")
[17:28:18.369]                         if (!has_future) {
[17:28:18.369]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.369]                             info)
[17:28:18.369]                         }
[17:28:18.369]                         else {
[17:28:18.369]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.369]                             info, version)
[17:28:18.369]                         }
[17:28:18.369]                         base::stop(msg)
[17:28:18.369]                       }
[17:28:18.369]                     })
[17:28:18.369]                   }
[17:28:18.369]                   ...future.strategy.old <- future::plan("list")
[17:28:18.369]                   options(future.plan = NULL)
[17:28:18.369]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.369]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.369]                 }
[17:28:18.369]                 ...future.workdir <- getwd()
[17:28:18.369]             }
[17:28:18.369]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.369]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.369]         }
[17:28:18.369]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.369]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.369]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.369]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.369]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.369]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.369]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.369]             base::names(...future.oldOptions))
[17:28:18.369]     }
[17:28:18.369]     if (FALSE) {
[17:28:18.369]     }
[17:28:18.369]     else {
[17:28:18.369]         if (TRUE) {
[17:28:18.369]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.369]                 open = "w")
[17:28:18.369]         }
[17:28:18.369]         else {
[17:28:18.369]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.369]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.369]         }
[17:28:18.369]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.369]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.369]             base::sink(type = "output", split = FALSE)
[17:28:18.369]             base::close(...future.stdout)
[17:28:18.369]         }, add = TRUE)
[17:28:18.369]     }
[17:28:18.369]     ...future.frame <- base::sys.nframe()
[17:28:18.369]     ...future.conditions <- base::list()
[17:28:18.369]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.369]     if (FALSE) {
[17:28:18.369]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.369]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.369]     }
[17:28:18.369]     ...future.result <- base::tryCatch({
[17:28:18.369]         base::withCallingHandlers({
[17:28:18.369]             ...future.value <- base::withVisible(base::local({
[17:28:18.369]                 sample(x, size = 1L)
[17:28:18.369]             }))
[17:28:18.369]             future::FutureResult(value = ...future.value$value, 
[17:28:18.369]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.369]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.369]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.369]                     ...future.globalenv.names))
[17:28:18.369]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.369]         }, condition = base::local({
[17:28:18.369]             c <- base::c
[17:28:18.369]             inherits <- base::inherits
[17:28:18.369]             invokeRestart <- base::invokeRestart
[17:28:18.369]             length <- base::length
[17:28:18.369]             list <- base::list
[17:28:18.369]             seq.int <- base::seq.int
[17:28:18.369]             signalCondition <- base::signalCondition
[17:28:18.369]             sys.calls <- base::sys.calls
[17:28:18.369]             `[[` <- base::`[[`
[17:28:18.369]             `+` <- base::`+`
[17:28:18.369]             `<<-` <- base::`<<-`
[17:28:18.369]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.369]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.369]                   3L)]
[17:28:18.369]             }
[17:28:18.369]             function(cond) {
[17:28:18.369]                 is_error <- inherits(cond, "error")
[17:28:18.369]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.369]                   NULL)
[17:28:18.369]                 if (is_error) {
[17:28:18.369]                   sessionInformation <- function() {
[17:28:18.369]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.369]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.369]                       search = base::search(), system = base::Sys.info())
[17:28:18.369]                   }
[17:28:18.369]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.369]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.369]                     cond$call), session = sessionInformation(), 
[17:28:18.369]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.369]                   signalCondition(cond)
[17:28:18.369]                 }
[17:28:18.369]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.369]                 "immediateCondition"))) {
[17:28:18.369]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.369]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.369]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.369]                   if (TRUE && !signal) {
[17:28:18.369]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.369]                     {
[17:28:18.369]                       inherits <- base::inherits
[17:28:18.369]                       invokeRestart <- base::invokeRestart
[17:28:18.369]                       is.null <- base::is.null
[17:28:18.369]                       muffled <- FALSE
[17:28:18.369]                       if (inherits(cond, "message")) {
[17:28:18.369]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.369]                         if (muffled) 
[17:28:18.369]                           invokeRestart("muffleMessage")
[17:28:18.369]                       }
[17:28:18.369]                       else if (inherits(cond, "warning")) {
[17:28:18.369]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.369]                         if (muffled) 
[17:28:18.369]                           invokeRestart("muffleWarning")
[17:28:18.369]                       }
[17:28:18.369]                       else if (inherits(cond, "condition")) {
[17:28:18.369]                         if (!is.null(pattern)) {
[17:28:18.369]                           computeRestarts <- base::computeRestarts
[17:28:18.369]                           grepl <- base::grepl
[17:28:18.369]                           restarts <- computeRestarts(cond)
[17:28:18.369]                           for (restart in restarts) {
[17:28:18.369]                             name <- restart$name
[17:28:18.369]                             if (is.null(name)) 
[17:28:18.369]                               next
[17:28:18.369]                             if (!grepl(pattern, name)) 
[17:28:18.369]                               next
[17:28:18.369]                             invokeRestart(restart)
[17:28:18.369]                             muffled <- TRUE
[17:28:18.369]                             break
[17:28:18.369]                           }
[17:28:18.369]                         }
[17:28:18.369]                       }
[17:28:18.369]                       invisible(muffled)
[17:28:18.369]                     }
[17:28:18.369]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.369]                   }
[17:28:18.369]                 }
[17:28:18.369]                 else {
[17:28:18.369]                   if (TRUE) {
[17:28:18.369]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.369]                     {
[17:28:18.369]                       inherits <- base::inherits
[17:28:18.369]                       invokeRestart <- base::invokeRestart
[17:28:18.369]                       is.null <- base::is.null
[17:28:18.369]                       muffled <- FALSE
[17:28:18.369]                       if (inherits(cond, "message")) {
[17:28:18.369]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.369]                         if (muffled) 
[17:28:18.369]                           invokeRestart("muffleMessage")
[17:28:18.369]                       }
[17:28:18.369]                       else if (inherits(cond, "warning")) {
[17:28:18.369]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.369]                         if (muffled) 
[17:28:18.369]                           invokeRestart("muffleWarning")
[17:28:18.369]                       }
[17:28:18.369]                       else if (inherits(cond, "condition")) {
[17:28:18.369]                         if (!is.null(pattern)) {
[17:28:18.369]                           computeRestarts <- base::computeRestarts
[17:28:18.369]                           grepl <- base::grepl
[17:28:18.369]                           restarts <- computeRestarts(cond)
[17:28:18.369]                           for (restart in restarts) {
[17:28:18.369]                             name <- restart$name
[17:28:18.369]                             if (is.null(name)) 
[17:28:18.369]                               next
[17:28:18.369]                             if (!grepl(pattern, name)) 
[17:28:18.369]                               next
[17:28:18.369]                             invokeRestart(restart)
[17:28:18.369]                             muffled <- TRUE
[17:28:18.369]                             break
[17:28:18.369]                           }
[17:28:18.369]                         }
[17:28:18.369]                       }
[17:28:18.369]                       invisible(muffled)
[17:28:18.369]                     }
[17:28:18.369]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.369]                   }
[17:28:18.369]                 }
[17:28:18.369]             }
[17:28:18.369]         }))
[17:28:18.369]     }, error = function(ex) {
[17:28:18.369]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.369]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.369]                 ...future.rng), started = ...future.startTime, 
[17:28:18.369]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.369]             version = "1.8"), class = "FutureResult")
[17:28:18.369]     }, finally = {
[17:28:18.369]         if (!identical(...future.workdir, getwd())) 
[17:28:18.369]             setwd(...future.workdir)
[17:28:18.369]         {
[17:28:18.369]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.369]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.369]             }
[17:28:18.369]             base::options(...future.oldOptions)
[17:28:18.369]             if (.Platform$OS.type == "windows") {
[17:28:18.369]                 old_names <- names(...future.oldEnvVars)
[17:28:18.369]                 envs <- base::Sys.getenv()
[17:28:18.369]                 names <- names(envs)
[17:28:18.369]                 common <- intersect(names, old_names)
[17:28:18.369]                 added <- setdiff(names, old_names)
[17:28:18.369]                 removed <- setdiff(old_names, names)
[17:28:18.369]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.369]                   envs[common]]
[17:28:18.369]                 NAMES <- toupper(changed)
[17:28:18.369]                 args <- list()
[17:28:18.369]                 for (kk in seq_along(NAMES)) {
[17:28:18.369]                   name <- changed[[kk]]
[17:28:18.369]                   NAME <- NAMES[[kk]]
[17:28:18.369]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.369]                     next
[17:28:18.369]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.369]                 }
[17:28:18.369]                 NAMES <- toupper(added)
[17:28:18.369]                 for (kk in seq_along(NAMES)) {
[17:28:18.369]                   name <- added[[kk]]
[17:28:18.369]                   NAME <- NAMES[[kk]]
[17:28:18.369]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.369]                     next
[17:28:18.369]                   args[[name]] <- ""
[17:28:18.369]                 }
[17:28:18.369]                 NAMES <- toupper(removed)
[17:28:18.369]                 for (kk in seq_along(NAMES)) {
[17:28:18.369]                   name <- removed[[kk]]
[17:28:18.369]                   NAME <- NAMES[[kk]]
[17:28:18.369]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.369]                     next
[17:28:18.369]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.369]                 }
[17:28:18.369]                 if (length(args) > 0) 
[17:28:18.369]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.369]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.369]             }
[17:28:18.369]             else {
[17:28:18.369]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.369]             }
[17:28:18.369]             {
[17:28:18.369]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.369]                   0L) {
[17:28:18.369]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.369]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.369]                   base::options(opts)
[17:28:18.369]                 }
[17:28:18.369]                 {
[17:28:18.369]                   {
[17:28:18.369]                     base::assign(".Random.seed", c(10407L, 1578556647L, 
[17:28:18.369]                     -772592193L, 1422475508L, -1203128252L, -1085515778L, 
[17:28:18.369]                     -1077665960L), envir = base::globalenv(), 
[17:28:18.369]                       inherits = FALSE)
[17:28:18.369]                     NULL
[17:28:18.369]                   }
[17:28:18.369]                   options(future.plan = NULL)
[17:28:18.369]                   if (is.na(NA_character_)) 
[17:28:18.369]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.369]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.369]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.369]                     .init = FALSE)
[17:28:18.369]                 }
[17:28:18.369]             }
[17:28:18.369]         }
[17:28:18.369]     })
[17:28:18.369]     if (TRUE) {
[17:28:18.369]         base::sink(type = "output", split = FALSE)
[17:28:18.369]         if (TRUE) {
[17:28:18.369]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.369]         }
[17:28:18.369]         else {
[17:28:18.369]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.369]         }
[17:28:18.369]         base::close(...future.stdout)
[17:28:18.369]         ...future.stdout <- NULL
[17:28:18.369]     }
[17:28:18.369]     ...future.result$conditions <- ...future.conditions
[17:28:18.369]     ...future.result$finished <- base::Sys.time()
[17:28:18.369]     ...future.result
[17:28:18.369] }
[17:28:18.373] assign_globals() ...
[17:28:18.373] List of 1
[17:28:18.373]  $ x: int [1:4] 0 1 2 3
[17:28:18.373]  - attr(*, "where")=List of 1
[17:28:18.373]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.373]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.373]  - attr(*, "resolved")= logi FALSE
[17:28:18.373]  - attr(*, "total_size")= num 64
[17:28:18.373]  - attr(*, "already-done")= logi TRUE
[17:28:18.376] - copied 'x' to environment
[17:28:18.376] assign_globals() ... done
[17:28:18.377] plan(): Setting new future strategy stack:
[17:28:18.377] List of future strategies:
[17:28:18.377] 1. sequential:
[17:28:18.377]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.377]    - tweaked: FALSE
[17:28:18.377]    - call: NULL
[17:28:18.377] plan(): nbrOfWorkers() = 1
[17:28:18.379] plan(): Setting new future strategy stack:
[17:28:18.379] List of future strategies:
[17:28:18.379] 1. sequential:
[17:28:18.379]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.379]    - tweaked: FALSE
[17:28:18.379]    - call: plan(strategy)
[17:28:18.379] plan(): nbrOfWorkers() = 1
[17:28:18.380] SequentialFuture started (and completed)
[17:28:18.380] - Launch lazy future ... done
[17:28:18.380] run() for 'SequentialFuture' ... done
[17:28:18.380] Future state: 'finished'
[17:28:18.381] signalConditions() ...
[17:28:18.381]  - include = 'condition'
[17:28:18.381]  - exclude = 'immediateCondition'
[17:28:18.381]  - resignal = TRUE
[17:28:18.381]  - Number of conditions: 1
[17:28:18.382]  - Condition #1: 'RngFutureWarning', 'FutureWarning', 'warning', 'RngFutureCondition', 'FutureCondition', 'condition'
[17:28:18.382] signalConditions() ... done
<RngFutureWarning: UNRELIABLE VALUE: Future ('fsample_1-163723') 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: 8e925045-bf78-893c-eb53-3c9b2da3867a


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

DEBUG: END TROUBLESHOOTING HELP
[17:28:18.383] getGlobalsAndPackages() ...
[17:28:18.383] Searching for globals...
[17:28:18.384] - globals found: [3] '{', 'sample', 'x'
[17:28:18.386] Searching for globals ... DONE
[17:28:18.386] Resolving globals: FALSE
[17:28:18.386] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.387] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.387] - globals: [1] 'x'
[17:28:18.387] 
[17:28:18.387] getGlobalsAndPackages() ... DONE
[17:28:18.388] run() for 'Future' ...
[17:28:18.388] - state: 'created'
[17:28:18.388] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.388] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.389] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.389]   - Field: 'label'
[17:28:18.389]   - Field: 'local'
[17:28:18.389]   - Field: 'owner'
[17:28:18.389]   - Field: 'envir'
[17:28:18.389]   - Field: 'packages'
[17:28:18.390]   - Field: 'gc'
[17:28:18.390]   - Field: 'conditions'
[17:28:18.390]   - Field: 'expr'
[17:28:18.390]   - Field: 'uuid'
[17:28:18.391]   - Field: 'seed'
[17:28:18.391]   - Field: 'version'
[17:28:18.391]   - Field: 'result'
[17:28:18.391]   - Field: 'asynchronous'
[17:28:18.391]   - Field: 'calls'
[17:28:18.391]   - Field: 'globals'
[17:28:18.392]   - Field: 'stdout'
[17:28:18.392]   - Field: 'earlySignal'
[17:28:18.392]   - Field: 'lazy'
[17:28:18.392]   - Field: 'state'
[17:28:18.392] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.392] - Launch lazy future ...
[17:28:18.393] Packages needed by the future expression (n = 0): <none>
[17:28:18.393] Packages needed by future strategies (n = 0): <none>
[17:28:18.393] {
[17:28:18.393]     {
[17:28:18.393]         {
[17:28:18.393]             ...future.startTime <- base::Sys.time()
[17:28:18.393]             {
[17:28:18.393]                 {
[17:28:18.393]                   {
[17:28:18.393]                     base::local({
[17:28:18.393]                       has_future <- base::requireNamespace("future", 
[17:28:18.393]                         quietly = TRUE)
[17:28:18.393]                       if (has_future) {
[17:28:18.393]                         ns <- base::getNamespace("future")
[17:28:18.393]                         version <- ns[[".package"]][["version"]]
[17:28:18.393]                         if (is.null(version)) 
[17:28:18.393]                           version <- utils::packageVersion("future")
[17:28:18.393]                       }
[17:28:18.393]                       else {
[17:28:18.393]                         version <- NULL
[17:28:18.393]                       }
[17:28:18.393]                       if (!has_future || version < "1.8.0") {
[17:28:18.393]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.393]                           "", base::R.version$version.string), 
[17:28:18.393]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.393]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.393]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.393]                             "release", "version")], collapse = " "), 
[17:28:18.393]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.393]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.393]                           info)
[17:28:18.393]                         info <- base::paste(info, collapse = "; ")
[17:28:18.393]                         if (!has_future) {
[17:28:18.393]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.393]                             info)
[17:28:18.393]                         }
[17:28:18.393]                         else {
[17:28:18.393]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.393]                             info, version)
[17:28:18.393]                         }
[17:28:18.393]                         base::stop(msg)
[17:28:18.393]                       }
[17:28:18.393]                     })
[17:28:18.393]                   }
[17:28:18.393]                   ...future.strategy.old <- future::plan("list")
[17:28:18.393]                   options(future.plan = NULL)
[17:28:18.393]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.393]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.393]                 }
[17:28:18.393]                 ...future.workdir <- getwd()
[17:28:18.393]             }
[17:28:18.393]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.393]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.393]         }
[17:28:18.393]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.393]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.393]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.393]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.393]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.393]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.393]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.393]             base::names(...future.oldOptions))
[17:28:18.393]     }
[17:28:18.393]     if (FALSE) {
[17:28:18.393]     }
[17:28:18.393]     else {
[17:28:18.393]         if (TRUE) {
[17:28:18.393]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.393]                 open = "w")
[17:28:18.393]         }
[17:28:18.393]         else {
[17:28:18.393]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.393]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.393]         }
[17:28:18.393]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.393]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.393]             base::sink(type = "output", split = FALSE)
[17:28:18.393]             base::close(...future.stdout)
[17:28:18.393]         }, add = TRUE)
[17:28:18.393]     }
[17:28:18.393]     ...future.frame <- base::sys.nframe()
[17:28:18.393]     ...future.conditions <- base::list()
[17:28:18.393]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.393]     if (FALSE) {
[17:28:18.393]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.393]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.393]     }
[17:28:18.393]     ...future.result <- base::tryCatch({
[17:28:18.393]         base::withCallingHandlers({
[17:28:18.393]             ...future.value <- base::withVisible(base::local({
[17:28:18.393]                 sample(x, size = 1L)
[17:28:18.393]             }))
[17:28:18.393]             future::FutureResult(value = ...future.value$value, 
[17:28:18.393]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.393]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.393]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.393]                     ...future.globalenv.names))
[17:28:18.393]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.393]         }, condition = base::local({
[17:28:18.393]             c <- base::c
[17:28:18.393]             inherits <- base::inherits
[17:28:18.393]             invokeRestart <- base::invokeRestart
[17:28:18.393]             length <- base::length
[17:28:18.393]             list <- base::list
[17:28:18.393]             seq.int <- base::seq.int
[17:28:18.393]             signalCondition <- base::signalCondition
[17:28:18.393]             sys.calls <- base::sys.calls
[17:28:18.393]             `[[` <- base::`[[`
[17:28:18.393]             `+` <- base::`+`
[17:28:18.393]             `<<-` <- base::`<<-`
[17:28:18.393]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.393]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.393]                   3L)]
[17:28:18.393]             }
[17:28:18.393]             function(cond) {
[17:28:18.393]                 is_error <- inherits(cond, "error")
[17:28:18.393]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.393]                   NULL)
[17:28:18.393]                 if (is_error) {
[17:28:18.393]                   sessionInformation <- function() {
[17:28:18.393]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.393]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.393]                       search = base::search(), system = base::Sys.info())
[17:28:18.393]                   }
[17:28:18.393]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.393]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.393]                     cond$call), session = sessionInformation(), 
[17:28:18.393]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.393]                   signalCondition(cond)
[17:28:18.393]                 }
[17:28:18.393]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.393]                 "immediateCondition"))) {
[17:28:18.393]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.393]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.393]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.393]                   if (TRUE && !signal) {
[17:28:18.393]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.393]                     {
[17:28:18.393]                       inherits <- base::inherits
[17:28:18.393]                       invokeRestart <- base::invokeRestart
[17:28:18.393]                       is.null <- base::is.null
[17:28:18.393]                       muffled <- FALSE
[17:28:18.393]                       if (inherits(cond, "message")) {
[17:28:18.393]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.393]                         if (muffled) 
[17:28:18.393]                           invokeRestart("muffleMessage")
[17:28:18.393]                       }
[17:28:18.393]                       else if (inherits(cond, "warning")) {
[17:28:18.393]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.393]                         if (muffled) 
[17:28:18.393]                           invokeRestart("muffleWarning")
[17:28:18.393]                       }
[17:28:18.393]                       else if (inherits(cond, "condition")) {
[17:28:18.393]                         if (!is.null(pattern)) {
[17:28:18.393]                           computeRestarts <- base::computeRestarts
[17:28:18.393]                           grepl <- base::grepl
[17:28:18.393]                           restarts <- computeRestarts(cond)
[17:28:18.393]                           for (restart in restarts) {
[17:28:18.393]                             name <- restart$name
[17:28:18.393]                             if (is.null(name)) 
[17:28:18.393]                               next
[17:28:18.393]                             if (!grepl(pattern, name)) 
[17:28:18.393]                               next
[17:28:18.393]                             invokeRestart(restart)
[17:28:18.393]                             muffled <- TRUE
[17:28:18.393]                             break
[17:28:18.393]                           }
[17:28:18.393]                         }
[17:28:18.393]                       }
[17:28:18.393]                       invisible(muffled)
[17:28:18.393]                     }
[17:28:18.393]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.393]                   }
[17:28:18.393]                 }
[17:28:18.393]                 else {
[17:28:18.393]                   if (TRUE) {
[17:28:18.393]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.393]                     {
[17:28:18.393]                       inherits <- base::inherits
[17:28:18.393]                       invokeRestart <- base::invokeRestart
[17:28:18.393]                       is.null <- base::is.null
[17:28:18.393]                       muffled <- FALSE
[17:28:18.393]                       if (inherits(cond, "message")) {
[17:28:18.393]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.393]                         if (muffled) 
[17:28:18.393]                           invokeRestart("muffleMessage")
[17:28:18.393]                       }
[17:28:18.393]                       else if (inherits(cond, "warning")) {
[17:28:18.393]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.393]                         if (muffled) 
[17:28:18.393]                           invokeRestart("muffleWarning")
[17:28:18.393]                       }
[17:28:18.393]                       else if (inherits(cond, "condition")) {
[17:28:18.393]                         if (!is.null(pattern)) {
[17:28:18.393]                           computeRestarts <- base::computeRestarts
[17:28:18.393]                           grepl <- base::grepl
[17:28:18.393]                           restarts <- computeRestarts(cond)
[17:28:18.393]                           for (restart in restarts) {
[17:28:18.393]                             name <- restart$name
[17:28:18.393]                             if (is.null(name)) 
[17:28:18.393]                               next
[17:28:18.393]                             if (!grepl(pattern, name)) 
[17:28:18.393]                               next
[17:28:18.393]                             invokeRestart(restart)
[17:28:18.393]                             muffled <- TRUE
[17:28:18.393]                             break
[17:28:18.393]                           }
[17:28:18.393]                         }
[17:28:18.393]                       }
[17:28:18.393]                       invisible(muffled)
[17:28:18.393]                     }
[17:28:18.393]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.393]                   }
[17:28:18.393]                 }
[17:28:18.393]             }
[17:28:18.393]         }))
[17:28:18.393]     }, error = function(ex) {
[17:28:18.393]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.393]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.393]                 ...future.rng), started = ...future.startTime, 
[17:28:18.393]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.393]             version = "1.8"), class = "FutureResult")
[17:28:18.393]     }, finally = {
[17:28:18.393]         if (!identical(...future.workdir, getwd())) 
[17:28:18.393]             setwd(...future.workdir)
[17:28:18.393]         {
[17:28:18.393]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.393]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.393]             }
[17:28:18.393]             base::options(...future.oldOptions)
[17:28:18.393]             if (.Platform$OS.type == "windows") {
[17:28:18.393]                 old_names <- names(...future.oldEnvVars)
[17:28:18.393]                 envs <- base::Sys.getenv()
[17:28:18.393]                 names <- names(envs)
[17:28:18.393]                 common <- intersect(names, old_names)
[17:28:18.393]                 added <- setdiff(names, old_names)
[17:28:18.393]                 removed <- setdiff(old_names, names)
[17:28:18.393]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.393]                   envs[common]]
[17:28:18.393]                 NAMES <- toupper(changed)
[17:28:18.393]                 args <- list()
[17:28:18.393]                 for (kk in seq_along(NAMES)) {
[17:28:18.393]                   name <- changed[[kk]]
[17:28:18.393]                   NAME <- NAMES[[kk]]
[17:28:18.393]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.393]                     next
[17:28:18.393]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.393]                 }
[17:28:18.393]                 NAMES <- toupper(added)
[17:28:18.393]                 for (kk in seq_along(NAMES)) {
[17:28:18.393]                   name <- added[[kk]]
[17:28:18.393]                   NAME <- NAMES[[kk]]
[17:28:18.393]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.393]                     next
[17:28:18.393]                   args[[name]] <- ""
[17:28:18.393]                 }
[17:28:18.393]                 NAMES <- toupper(removed)
[17:28:18.393]                 for (kk in seq_along(NAMES)) {
[17:28:18.393]                   name <- removed[[kk]]
[17:28:18.393]                   NAME <- NAMES[[kk]]
[17:28:18.393]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.393]                     next
[17:28:18.393]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.393]                 }
[17:28:18.393]                 if (length(args) > 0) 
[17:28:18.393]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.393]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.393]             }
[17:28:18.393]             else {
[17:28:18.393]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.393]             }
[17:28:18.393]             {
[17:28:18.393]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.393]                   0L) {
[17:28:18.393]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.393]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.393]                   base::options(opts)
[17:28:18.393]                 }
[17:28:18.393]                 {
[17:28:18.393]                   {
[17:28:18.393]                     base::assign(".Random.seed", c(10407L, -1559578278L, 
[17:28:18.393]                     710902500L, -844755408L, 1082501593L, -1770190531L, 
[17:28:18.393]                     1407237460L), envir = base::globalenv(), 
[17:28:18.393]                       inherits = FALSE)
[17:28:18.393]                     NULL
[17:28:18.393]                   }
[17:28:18.393]                   options(future.plan = NULL)
[17:28:18.393]                   if (is.na(NA_character_)) 
[17:28:18.393]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.393]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.393]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.393]                     .init = FALSE)
[17:28:18.393]                 }
[17:28:18.393]             }
[17:28:18.393]         }
[17:28:18.393]     })
[17:28:18.393]     if (TRUE) {
[17:28:18.393]         base::sink(type = "output", split = FALSE)
[17:28:18.393]         if (TRUE) {
[17:28:18.393]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.393]         }
[17:28:18.393]         else {
[17:28:18.393]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.393]         }
[17:28:18.393]         base::close(...future.stdout)
[17:28:18.393]         ...future.stdout <- NULL
[17:28:18.393]     }
[17:28:18.393]     ...future.result$conditions <- ...future.conditions
[17:28:18.393]     ...future.result$finished <- base::Sys.time()
[17:28:18.393]     ...future.result
[17:28:18.393] }
[17:28:18.397] assign_globals() ...
[17:28:18.397] List of 1
[17:28:18.397]  $ x: int [1:4] 0 1 2 3
[17:28:18.397]  - attr(*, "where")=List of 1
[17:28:18.397]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.397]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.397]  - attr(*, "resolved")= logi FALSE
[17:28:18.397]  - attr(*, "total_size")= num 64
[17:28:18.397]  - attr(*, "already-done")= logi TRUE
[17:28:18.400] - copied 'x' to environment
[17:28:18.400] assign_globals() ... done
[17:28:18.401] plan(): Setting new future strategy stack:
[17:28:18.401] List of future strategies:
[17:28:18.401] 1. sequential:
[17:28:18.401]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.401]    - tweaked: FALSE
[17:28:18.401]    - call: NULL
[17:28:18.401] plan(): nbrOfWorkers() = 1
[17:28:18.402] plan(): Setting new future strategy stack:
[17:28:18.403] List of future strategies:
[17:28:18.403] 1. sequential:
[17:28:18.403]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.403]    - tweaked: FALSE
[17:28:18.403]    - call: plan(strategy)
[17:28:18.403] plan(): nbrOfWorkers() = 1
[17:28:18.404] SequentialFuture started (and completed)
[17:28:18.404] - Launch lazy future ... done
[17:28:18.404] run() for 'SequentialFuture' ... done
[17:28:18.404] getGlobalsAndPackages() ...
[17:28:18.405] Searching for globals...
[17:28:18.406] - globals found: [3] '{', 'sample', 'x'
[17:28:18.406] Searching for globals ... DONE
[17:28:18.406] Resolving globals: FALSE
[17:28:18.407] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.407] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.407] - globals: [1] 'x'
[17:28:18.407] 
[17:28:18.407] getGlobalsAndPackages() ... DONE
[17:28:18.408] run() for 'Future' ...
[17:28:18.408] - state: 'created'
[17:28:18.408] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.409] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.409] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.409]   - Field: 'label'
[17:28:18.409]   - Field: 'local'
[17:28:18.409]   - Field: 'owner'
[17:28:18.409]   - Field: 'envir'
[17:28:18.410]   - Field: 'packages'
[17:28:18.410]   - Field: 'gc'
[17:28:18.410]   - Field: 'conditions'
[17:28:18.410]   - Field: 'expr'
[17:28:18.410]   - Field: 'uuid'
[17:28:18.410]   - Field: 'seed'
[17:28:18.411]   - Field: 'version'
[17:28:18.411]   - Field: 'result'
[17:28:18.411]   - Field: 'asynchronous'
[17:28:18.411]   - Field: 'calls'
[17:28:18.411]   - Field: 'globals'
[17:28:18.411]   - Field: 'stdout'
[17:28:18.412]   - Field: 'earlySignal'
[17:28:18.412]   - Field: 'lazy'
[17:28:18.412]   - Field: 'state'
[17:28:18.412] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.412] - Launch lazy future ...
[17:28:18.413] Packages needed by the future expression (n = 0): <none>
[17:28:18.413] Packages needed by future strategies (n = 0): <none>
[17:28:18.413] {
[17:28:18.413]     {
[17:28:18.413]         {
[17:28:18.413]             ...future.startTime <- base::Sys.time()
[17:28:18.413]             {
[17:28:18.413]                 {
[17:28:18.413]                   {
[17:28:18.413]                     base::local({
[17:28:18.413]                       has_future <- base::requireNamespace("future", 
[17:28:18.413]                         quietly = TRUE)
[17:28:18.413]                       if (has_future) {
[17:28:18.413]                         ns <- base::getNamespace("future")
[17:28:18.413]                         version <- ns[[".package"]][["version"]]
[17:28:18.413]                         if (is.null(version)) 
[17:28:18.413]                           version <- utils::packageVersion("future")
[17:28:18.413]                       }
[17:28:18.413]                       else {
[17:28:18.413]                         version <- NULL
[17:28:18.413]                       }
[17:28:18.413]                       if (!has_future || version < "1.8.0") {
[17:28:18.413]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.413]                           "", base::R.version$version.string), 
[17:28:18.413]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.413]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.413]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.413]                             "release", "version")], collapse = " "), 
[17:28:18.413]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.413]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.413]                           info)
[17:28:18.413]                         info <- base::paste(info, collapse = "; ")
[17:28:18.413]                         if (!has_future) {
[17:28:18.413]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.413]                             info)
[17:28:18.413]                         }
[17:28:18.413]                         else {
[17:28:18.413]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.413]                             info, version)
[17:28:18.413]                         }
[17:28:18.413]                         base::stop(msg)
[17:28:18.413]                       }
[17:28:18.413]                     })
[17:28:18.413]                   }
[17:28:18.413]                   ...future.strategy.old <- future::plan("list")
[17:28:18.413]                   options(future.plan = NULL)
[17:28:18.413]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.413]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.413]                 }
[17:28:18.413]                 ...future.workdir <- getwd()
[17:28:18.413]             }
[17:28:18.413]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.413]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.413]         }
[17:28:18.413]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.413]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.413]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.413]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.413]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.413]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.413]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.413]             base::names(...future.oldOptions))
[17:28:18.413]     }
[17:28:18.413]     if (FALSE) {
[17:28:18.413]     }
[17:28:18.413]     else {
[17:28:18.413]         if (TRUE) {
[17:28:18.413]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.413]                 open = "w")
[17:28:18.413]         }
[17:28:18.413]         else {
[17:28:18.413]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.413]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.413]         }
[17:28:18.413]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.413]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.413]             base::sink(type = "output", split = FALSE)
[17:28:18.413]             base::close(...future.stdout)
[17:28:18.413]         }, add = TRUE)
[17:28:18.413]     }
[17:28:18.413]     ...future.frame <- base::sys.nframe()
[17:28:18.413]     ...future.conditions <- base::list()
[17:28:18.413]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.413]     if (FALSE) {
[17:28:18.413]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.413]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.413]     }
[17:28:18.413]     ...future.result <- base::tryCatch({
[17:28:18.413]         base::withCallingHandlers({
[17:28:18.413]             ...future.value <- base::withVisible(base::local({
[17:28:18.413]                 sample(x, size = 1L)
[17:28:18.413]             }))
[17:28:18.413]             future::FutureResult(value = ...future.value$value, 
[17:28:18.413]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.413]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.413]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.413]                     ...future.globalenv.names))
[17:28:18.413]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.413]         }, condition = base::local({
[17:28:18.413]             c <- base::c
[17:28:18.413]             inherits <- base::inherits
[17:28:18.413]             invokeRestart <- base::invokeRestart
[17:28:18.413]             length <- base::length
[17:28:18.413]             list <- base::list
[17:28:18.413]             seq.int <- base::seq.int
[17:28:18.413]             signalCondition <- base::signalCondition
[17:28:18.413]             sys.calls <- base::sys.calls
[17:28:18.413]             `[[` <- base::`[[`
[17:28:18.413]             `+` <- base::`+`
[17:28:18.413]             `<<-` <- base::`<<-`
[17:28:18.413]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.413]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.413]                   3L)]
[17:28:18.413]             }
[17:28:18.413]             function(cond) {
[17:28:18.413]                 is_error <- inherits(cond, "error")
[17:28:18.413]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.413]                   NULL)
[17:28:18.413]                 if (is_error) {
[17:28:18.413]                   sessionInformation <- function() {
[17:28:18.413]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.413]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.413]                       search = base::search(), system = base::Sys.info())
[17:28:18.413]                   }
[17:28:18.413]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.413]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.413]                     cond$call), session = sessionInformation(), 
[17:28:18.413]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.413]                   signalCondition(cond)
[17:28:18.413]                 }
[17:28:18.413]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.413]                 "immediateCondition"))) {
[17:28:18.413]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.413]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.413]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.413]                   if (TRUE && !signal) {
[17:28:18.413]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.413]                     {
[17:28:18.413]                       inherits <- base::inherits
[17:28:18.413]                       invokeRestart <- base::invokeRestart
[17:28:18.413]                       is.null <- base::is.null
[17:28:18.413]                       muffled <- FALSE
[17:28:18.413]                       if (inherits(cond, "message")) {
[17:28:18.413]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.413]                         if (muffled) 
[17:28:18.413]                           invokeRestart("muffleMessage")
[17:28:18.413]                       }
[17:28:18.413]                       else if (inherits(cond, "warning")) {
[17:28:18.413]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.413]                         if (muffled) 
[17:28:18.413]                           invokeRestart("muffleWarning")
[17:28:18.413]                       }
[17:28:18.413]                       else if (inherits(cond, "condition")) {
[17:28:18.413]                         if (!is.null(pattern)) {
[17:28:18.413]                           computeRestarts <- base::computeRestarts
[17:28:18.413]                           grepl <- base::grepl
[17:28:18.413]                           restarts <- computeRestarts(cond)
[17:28:18.413]                           for (restart in restarts) {
[17:28:18.413]                             name <- restart$name
[17:28:18.413]                             if (is.null(name)) 
[17:28:18.413]                               next
[17:28:18.413]                             if (!grepl(pattern, name)) 
[17:28:18.413]                               next
[17:28:18.413]                             invokeRestart(restart)
[17:28:18.413]                             muffled <- TRUE
[17:28:18.413]                             break
[17:28:18.413]                           }
[17:28:18.413]                         }
[17:28:18.413]                       }
[17:28:18.413]                       invisible(muffled)
[17:28:18.413]                     }
[17:28:18.413]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.413]                   }
[17:28:18.413]                 }
[17:28:18.413]                 else {
[17:28:18.413]                   if (TRUE) {
[17:28:18.413]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.413]                     {
[17:28:18.413]                       inherits <- base::inherits
[17:28:18.413]                       invokeRestart <- base::invokeRestart
[17:28:18.413]                       is.null <- base::is.null
[17:28:18.413]                       muffled <- FALSE
[17:28:18.413]                       if (inherits(cond, "message")) {
[17:28:18.413]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.413]                         if (muffled) 
[17:28:18.413]                           invokeRestart("muffleMessage")
[17:28:18.413]                       }
[17:28:18.413]                       else if (inherits(cond, "warning")) {
[17:28:18.413]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.413]                         if (muffled) 
[17:28:18.413]                           invokeRestart("muffleWarning")
[17:28:18.413]                       }
[17:28:18.413]                       else if (inherits(cond, "condition")) {
[17:28:18.413]                         if (!is.null(pattern)) {
[17:28:18.413]                           computeRestarts <- base::computeRestarts
[17:28:18.413]                           grepl <- base::grepl
[17:28:18.413]                           restarts <- computeRestarts(cond)
[17:28:18.413]                           for (restart in restarts) {
[17:28:18.413]                             name <- restart$name
[17:28:18.413]                             if (is.null(name)) 
[17:28:18.413]                               next
[17:28:18.413]                             if (!grepl(pattern, name)) 
[17:28:18.413]                               next
[17:28:18.413]                             invokeRestart(restart)
[17:28:18.413]                             muffled <- TRUE
[17:28:18.413]                             break
[17:28:18.413]                           }
[17:28:18.413]                         }
[17:28:18.413]                       }
[17:28:18.413]                       invisible(muffled)
[17:28:18.413]                     }
[17:28:18.413]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.413]                   }
[17:28:18.413]                 }
[17:28:18.413]             }
[17:28:18.413]         }))
[17:28:18.413]     }, error = function(ex) {
[17:28:18.413]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.413]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.413]                 ...future.rng), started = ...future.startTime, 
[17:28:18.413]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.413]             version = "1.8"), class = "FutureResult")
[17:28:18.413]     }, finally = {
[17:28:18.413]         if (!identical(...future.workdir, getwd())) 
[17:28:18.413]             setwd(...future.workdir)
[17:28:18.413]         {
[17:28:18.413]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.413]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.413]             }
[17:28:18.413]             base::options(...future.oldOptions)
[17:28:18.413]             if (.Platform$OS.type == "windows") {
[17:28:18.413]                 old_names <- names(...future.oldEnvVars)
[17:28:18.413]                 envs <- base::Sys.getenv()
[17:28:18.413]                 names <- names(envs)
[17:28:18.413]                 common <- intersect(names, old_names)
[17:28:18.413]                 added <- setdiff(names, old_names)
[17:28:18.413]                 removed <- setdiff(old_names, names)
[17:28:18.413]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.413]                   envs[common]]
[17:28:18.413]                 NAMES <- toupper(changed)
[17:28:18.413]                 args <- list()
[17:28:18.413]                 for (kk in seq_along(NAMES)) {
[17:28:18.413]                   name <- changed[[kk]]
[17:28:18.413]                   NAME <- NAMES[[kk]]
[17:28:18.413]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.413]                     next
[17:28:18.413]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.413]                 }
[17:28:18.413]                 NAMES <- toupper(added)
[17:28:18.413]                 for (kk in seq_along(NAMES)) {
[17:28:18.413]                   name <- added[[kk]]
[17:28:18.413]                   NAME <- NAMES[[kk]]
[17:28:18.413]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.413]                     next
[17:28:18.413]                   args[[name]] <- ""
[17:28:18.413]                 }
[17:28:18.413]                 NAMES <- toupper(removed)
[17:28:18.413]                 for (kk in seq_along(NAMES)) {
[17:28:18.413]                   name <- removed[[kk]]
[17:28:18.413]                   NAME <- NAMES[[kk]]
[17:28:18.413]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.413]                     next
[17:28:18.413]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.413]                 }
[17:28:18.413]                 if (length(args) > 0) 
[17:28:18.413]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.413]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.413]             }
[17:28:18.413]             else {
[17:28:18.413]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.413]             }
[17:28:18.413]             {
[17:28:18.413]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.413]                   0L) {
[17:28:18.413]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.413]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.413]                   base::options(opts)
[17:28:18.413]                 }
[17:28:18.413]                 {
[17:28:18.413]                   {
[17:28:18.413]                     base::assign(".Random.seed", c(10407L, -844755408L, 
[17:28:18.413]                     25280462L, 1658044765L, 1407237460L, 2042259082L, 
[17:28:18.413]                     1623183973L), envir = base::globalenv(), 
[17:28:18.413]                       inherits = FALSE)
[17:28:18.413]                     NULL
[17:28:18.413]                   }
[17:28:18.413]                   options(future.plan = NULL)
[17:28:18.413]                   if (is.na(NA_character_)) 
[17:28:18.413]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.413]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.413]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.413]                     .init = FALSE)
[17:28:18.413]                 }
[17:28:18.413]             }
[17:28:18.413]         }
[17:28:18.413]     })
[17:28:18.413]     if (TRUE) {
[17:28:18.413]         base::sink(type = "output", split = FALSE)
[17:28:18.413]         if (TRUE) {
[17:28:18.413]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.413]         }
[17:28:18.413]         else {
[17:28:18.413]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.413]         }
[17:28:18.413]         base::close(...future.stdout)
[17:28:18.413]         ...future.stdout <- NULL
[17:28:18.413]     }
[17:28:18.413]     ...future.result$conditions <- ...future.conditions
[17:28:18.413]     ...future.result$finished <- base::Sys.time()
[17:28:18.413]     ...future.result
[17:28:18.413] }
[17:28:18.417] assign_globals() ...
[17:28:18.417] List of 1
[17:28:18.417]  $ x: int [1:4] 0 1 2 3
[17:28:18.417]  - attr(*, "where")=List of 1
[17:28:18.417]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.417]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.417]  - attr(*, "resolved")= logi FALSE
[17:28:18.417]  - attr(*, "total_size")= num 64
[17:28:18.417]  - attr(*, "already-done")= logi TRUE
[17:28:18.421] - copied 'x' to environment
[17:28:18.421] assign_globals() ... done
[17:28:18.422] plan(): Setting new future strategy stack:
[17:28:18.422] List of future strategies:
[17:28:18.422] 1. sequential:
[17:28:18.422]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.422]    - tweaked: FALSE
[17:28:18.422]    - call: NULL
[17:28:18.422] plan(): nbrOfWorkers() = 1
[17:28:18.424] plan(): Setting new future strategy stack:
[17:28:18.424] List of future strategies:
[17:28:18.424] 1. sequential:
[17:28:18.424]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.424]    - tweaked: FALSE
[17:28:18.424]    - call: plan(strategy)
[17:28:18.424] plan(): nbrOfWorkers() = 1
[17:28:18.425] SequentialFuture started (and completed)
[17:28:18.425] - Launch lazy future ... done
[17:28:18.425] run() for 'SequentialFuture' ... done
[17:28:18.426] getGlobalsAndPackages() ...
[17:28:18.426] Searching for globals...
[17:28:18.427] - globals found: [3] '{', 'sample', 'x'
[17:28:18.427] Searching for globals ... DONE
[17:28:18.427] Resolving globals: FALSE
[17:28:18.428] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.428] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.428] - globals: [1] 'x'
[17:28:18.428] 
[17:28:18.429] getGlobalsAndPackages() ... DONE
[17:28:18.429] run() for 'Future' ...
[17:28:18.429] - state: 'created'
[17:28:18.429] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.430] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.430] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.430]   - Field: 'label'
[17:28:18.430]   - Field: 'local'
[17:28:18.430]   - Field: 'owner'
[17:28:18.431]   - Field: 'envir'
[17:28:18.431]   - Field: 'packages'
[17:28:18.431]   - Field: 'gc'
[17:28:18.431]   - Field: 'conditions'
[17:28:18.431]   - Field: 'expr'
[17:28:18.431]   - Field: 'uuid'
[17:28:18.432]   - Field: 'seed'
[17:28:18.432]   - Field: 'version'
[17:28:18.432]   - Field: 'result'
[17:28:18.432]   - Field: 'asynchronous'
[17:28:18.432]   - Field: 'calls'
[17:28:18.432]   - Field: 'globals'
[17:28:18.433]   - Field: 'stdout'
[17:28:18.433]   - Field: 'earlySignal'
[17:28:18.433]   - Field: 'lazy'
[17:28:18.433]   - Field: 'state'
[17:28:18.433] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.433] - Launch lazy future ...
[17:28:18.434] Packages needed by the future expression (n = 0): <none>
[17:28:18.434] Packages needed by future strategies (n = 0): <none>
[17:28:18.434] {
[17:28:18.434]     {
[17:28:18.434]         {
[17:28:18.434]             ...future.startTime <- base::Sys.time()
[17:28:18.434]             {
[17:28:18.434]                 {
[17:28:18.434]                   {
[17:28:18.434]                     base::local({
[17:28:18.434]                       has_future <- base::requireNamespace("future", 
[17:28:18.434]                         quietly = TRUE)
[17:28:18.434]                       if (has_future) {
[17:28:18.434]                         ns <- base::getNamespace("future")
[17:28:18.434]                         version <- ns[[".package"]][["version"]]
[17:28:18.434]                         if (is.null(version)) 
[17:28:18.434]                           version <- utils::packageVersion("future")
[17:28:18.434]                       }
[17:28:18.434]                       else {
[17:28:18.434]                         version <- NULL
[17:28:18.434]                       }
[17:28:18.434]                       if (!has_future || version < "1.8.0") {
[17:28:18.434]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.434]                           "", base::R.version$version.string), 
[17:28:18.434]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.434]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.434]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.434]                             "release", "version")], collapse = " "), 
[17:28:18.434]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.434]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.434]                           info)
[17:28:18.434]                         info <- base::paste(info, collapse = "; ")
[17:28:18.434]                         if (!has_future) {
[17:28:18.434]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.434]                             info)
[17:28:18.434]                         }
[17:28:18.434]                         else {
[17:28:18.434]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.434]                             info, version)
[17:28:18.434]                         }
[17:28:18.434]                         base::stop(msg)
[17:28:18.434]                       }
[17:28:18.434]                     })
[17:28:18.434]                   }
[17:28:18.434]                   ...future.strategy.old <- future::plan("list")
[17:28:18.434]                   options(future.plan = NULL)
[17:28:18.434]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.434]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.434]                 }
[17:28:18.434]                 ...future.workdir <- getwd()
[17:28:18.434]             }
[17:28:18.434]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.434]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.434]         }
[17:28:18.434]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.434]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.434]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.434]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.434]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.434]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.434]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.434]             base::names(...future.oldOptions))
[17:28:18.434]     }
[17:28:18.434]     if (FALSE) {
[17:28:18.434]     }
[17:28:18.434]     else {
[17:28:18.434]         if (TRUE) {
[17:28:18.434]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.434]                 open = "w")
[17:28:18.434]         }
[17:28:18.434]         else {
[17:28:18.434]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.434]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.434]         }
[17:28:18.434]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.434]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.434]             base::sink(type = "output", split = FALSE)
[17:28:18.434]             base::close(...future.stdout)
[17:28:18.434]         }, add = TRUE)
[17:28:18.434]     }
[17:28:18.434]     ...future.frame <- base::sys.nframe()
[17:28:18.434]     ...future.conditions <- base::list()
[17:28:18.434]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.434]     if (FALSE) {
[17:28:18.434]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.434]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.434]     }
[17:28:18.434]     ...future.result <- base::tryCatch({
[17:28:18.434]         base::withCallingHandlers({
[17:28:18.434]             ...future.value <- base::withVisible(base::local({
[17:28:18.434]                 sample(x, size = 1L)
[17:28:18.434]             }))
[17:28:18.434]             future::FutureResult(value = ...future.value$value, 
[17:28:18.434]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.434]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.434]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.434]                     ...future.globalenv.names))
[17:28:18.434]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.434]         }, condition = base::local({
[17:28:18.434]             c <- base::c
[17:28:18.434]             inherits <- base::inherits
[17:28:18.434]             invokeRestart <- base::invokeRestart
[17:28:18.434]             length <- base::length
[17:28:18.434]             list <- base::list
[17:28:18.434]             seq.int <- base::seq.int
[17:28:18.434]             signalCondition <- base::signalCondition
[17:28:18.434]             sys.calls <- base::sys.calls
[17:28:18.434]             `[[` <- base::`[[`
[17:28:18.434]             `+` <- base::`+`
[17:28:18.434]             `<<-` <- base::`<<-`
[17:28:18.434]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.434]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.434]                   3L)]
[17:28:18.434]             }
[17:28:18.434]             function(cond) {
[17:28:18.434]                 is_error <- inherits(cond, "error")
[17:28:18.434]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.434]                   NULL)
[17:28:18.434]                 if (is_error) {
[17:28:18.434]                   sessionInformation <- function() {
[17:28:18.434]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.434]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.434]                       search = base::search(), system = base::Sys.info())
[17:28:18.434]                   }
[17:28:18.434]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.434]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.434]                     cond$call), session = sessionInformation(), 
[17:28:18.434]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.434]                   signalCondition(cond)
[17:28:18.434]                 }
[17:28:18.434]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.434]                 "immediateCondition"))) {
[17:28:18.434]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.434]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.434]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.434]                   if (TRUE && !signal) {
[17:28:18.434]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.434]                     {
[17:28:18.434]                       inherits <- base::inherits
[17:28:18.434]                       invokeRestart <- base::invokeRestart
[17:28:18.434]                       is.null <- base::is.null
[17:28:18.434]                       muffled <- FALSE
[17:28:18.434]                       if (inherits(cond, "message")) {
[17:28:18.434]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.434]                         if (muffled) 
[17:28:18.434]                           invokeRestart("muffleMessage")
[17:28:18.434]                       }
[17:28:18.434]                       else if (inherits(cond, "warning")) {
[17:28:18.434]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.434]                         if (muffled) 
[17:28:18.434]                           invokeRestart("muffleWarning")
[17:28:18.434]                       }
[17:28:18.434]                       else if (inherits(cond, "condition")) {
[17:28:18.434]                         if (!is.null(pattern)) {
[17:28:18.434]                           computeRestarts <- base::computeRestarts
[17:28:18.434]                           grepl <- base::grepl
[17:28:18.434]                           restarts <- computeRestarts(cond)
[17:28:18.434]                           for (restart in restarts) {
[17:28:18.434]                             name <- restart$name
[17:28:18.434]                             if (is.null(name)) 
[17:28:18.434]                               next
[17:28:18.434]                             if (!grepl(pattern, name)) 
[17:28:18.434]                               next
[17:28:18.434]                             invokeRestart(restart)
[17:28:18.434]                             muffled <- TRUE
[17:28:18.434]                             break
[17:28:18.434]                           }
[17:28:18.434]                         }
[17:28:18.434]                       }
[17:28:18.434]                       invisible(muffled)
[17:28:18.434]                     }
[17:28:18.434]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.434]                   }
[17:28:18.434]                 }
[17:28:18.434]                 else {
[17:28:18.434]                   if (TRUE) {
[17:28:18.434]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.434]                     {
[17:28:18.434]                       inherits <- base::inherits
[17:28:18.434]                       invokeRestart <- base::invokeRestart
[17:28:18.434]                       is.null <- base::is.null
[17:28:18.434]                       muffled <- FALSE
[17:28:18.434]                       if (inherits(cond, "message")) {
[17:28:18.434]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.434]                         if (muffled) 
[17:28:18.434]                           invokeRestart("muffleMessage")
[17:28:18.434]                       }
[17:28:18.434]                       else if (inherits(cond, "warning")) {
[17:28:18.434]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.434]                         if (muffled) 
[17:28:18.434]                           invokeRestart("muffleWarning")
[17:28:18.434]                       }
[17:28:18.434]                       else if (inherits(cond, "condition")) {
[17:28:18.434]                         if (!is.null(pattern)) {
[17:28:18.434]                           computeRestarts <- base::computeRestarts
[17:28:18.434]                           grepl <- base::grepl
[17:28:18.434]                           restarts <- computeRestarts(cond)
[17:28:18.434]                           for (restart in restarts) {
[17:28:18.434]                             name <- restart$name
[17:28:18.434]                             if (is.null(name)) 
[17:28:18.434]                               next
[17:28:18.434]                             if (!grepl(pattern, name)) 
[17:28:18.434]                               next
[17:28:18.434]                             invokeRestart(restart)
[17:28:18.434]                             muffled <- TRUE
[17:28:18.434]                             break
[17:28:18.434]                           }
[17:28:18.434]                         }
[17:28:18.434]                       }
[17:28:18.434]                       invisible(muffled)
[17:28:18.434]                     }
[17:28:18.434]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.434]                   }
[17:28:18.434]                 }
[17:28:18.434]             }
[17:28:18.434]         }))
[17:28:18.434]     }, error = function(ex) {
[17:28:18.434]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.434]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.434]                 ...future.rng), started = ...future.startTime, 
[17:28:18.434]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.434]             version = "1.8"), class = "FutureResult")
[17:28:18.434]     }, finally = {
[17:28:18.434]         if (!identical(...future.workdir, getwd())) 
[17:28:18.434]             setwd(...future.workdir)
[17:28:18.434]         {
[17:28:18.434]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.434]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.434]             }
[17:28:18.434]             base::options(...future.oldOptions)
[17:28:18.434]             if (.Platform$OS.type == "windows") {
[17:28:18.434]                 old_names <- names(...future.oldEnvVars)
[17:28:18.434]                 envs <- base::Sys.getenv()
[17:28:18.434]                 names <- names(envs)
[17:28:18.434]                 common <- intersect(names, old_names)
[17:28:18.434]                 added <- setdiff(names, old_names)
[17:28:18.434]                 removed <- setdiff(old_names, names)
[17:28:18.434]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.434]                   envs[common]]
[17:28:18.434]                 NAMES <- toupper(changed)
[17:28:18.434]                 args <- list()
[17:28:18.434]                 for (kk in seq_along(NAMES)) {
[17:28:18.434]                   name <- changed[[kk]]
[17:28:18.434]                   NAME <- NAMES[[kk]]
[17:28:18.434]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.434]                     next
[17:28:18.434]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.434]                 }
[17:28:18.434]                 NAMES <- toupper(added)
[17:28:18.434]                 for (kk in seq_along(NAMES)) {
[17:28:18.434]                   name <- added[[kk]]
[17:28:18.434]                   NAME <- NAMES[[kk]]
[17:28:18.434]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.434]                     next
[17:28:18.434]                   args[[name]] <- ""
[17:28:18.434]                 }
[17:28:18.434]                 NAMES <- toupper(removed)
[17:28:18.434]                 for (kk in seq_along(NAMES)) {
[17:28:18.434]                   name <- removed[[kk]]
[17:28:18.434]                   NAME <- NAMES[[kk]]
[17:28:18.434]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.434]                     next
[17:28:18.434]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.434]                 }
[17:28:18.434]                 if (length(args) > 0) 
[17:28:18.434]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.434]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.434]             }
[17:28:18.434]             else {
[17:28:18.434]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.434]             }
[17:28:18.434]             {
[17:28:18.434]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.434]                   0L) {
[17:28:18.434]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.434]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.434]                   base::options(opts)
[17:28:18.434]                 }
[17:28:18.434]                 {
[17:28:18.434]                   {
[17:28:18.434]                     base::assign(".Random.seed", c(10407L, 1658044765L, 
[17:28:18.434]                     -2036003017L, 624480187L, 1623183973L, -1176807178L, 
[17:28:18.434]                     -708227568L), envir = base::globalenv(), 
[17:28:18.434]                       inherits = FALSE)
[17:28:18.434]                     NULL
[17:28:18.434]                   }
[17:28:18.434]                   options(future.plan = NULL)
[17:28:18.434]                   if (is.na(NA_character_)) 
[17:28:18.434]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.434]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.434]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.434]                     .init = FALSE)
[17:28:18.434]                 }
[17:28:18.434]             }
[17:28:18.434]         }
[17:28:18.434]     })
[17:28:18.434]     if (TRUE) {
[17:28:18.434]         base::sink(type = "output", split = FALSE)
[17:28:18.434]         if (TRUE) {
[17:28:18.434]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.434]         }
[17:28:18.434]         else {
[17:28:18.434]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.434]         }
[17:28:18.434]         base::close(...future.stdout)
[17:28:18.434]         ...future.stdout <- NULL
[17:28:18.434]     }
[17:28:18.434]     ...future.result$conditions <- ...future.conditions
[17:28:18.434]     ...future.result$finished <- base::Sys.time()
[17:28:18.434]     ...future.result
[17:28:18.434] }
[17:28:18.438] assign_globals() ...
[17:28:18.438] List of 1
[17:28:18.438]  $ x: int [1:4] 0 1 2 3
[17:28:18.438]  - attr(*, "where")=List of 1
[17:28:18.438]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.438]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.438]  - attr(*, "resolved")= logi FALSE
[17:28:18.438]  - attr(*, "total_size")= num 64
[17:28:18.438]  - attr(*, "already-done")= logi TRUE
[17:28:18.441] - copied 'x' to environment
[17:28:18.441] assign_globals() ... done
[17:28:18.442] plan(): Setting new future strategy stack:
[17:28:18.442] List of future strategies:
[17:28:18.442] 1. sequential:
[17:28:18.442]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.442]    - tweaked: FALSE
[17:28:18.442]    - call: NULL
[17:28:18.443] plan(): nbrOfWorkers() = 1
[17:28:18.444] plan(): Setting new future strategy stack:
[17:28:18.444] List of future strategies:
[17:28:18.444] 1. sequential:
[17:28:18.444]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.444]    - tweaked: FALSE
[17:28:18.444]    - call: plan(strategy)
[17:28:18.444] plan(): nbrOfWorkers() = 1
[17:28:18.445] SequentialFuture started (and completed)
[17:28:18.445] - Launch lazy future ... done
[17:28:18.445] run() for 'SequentialFuture' ... done
[17:28:18.446] getGlobalsAndPackages() ...
[17:28:18.446] Searching for globals...
[17:28:18.447] - globals found: [3] '{', 'sample', 'x'
[17:28:18.448] Searching for globals ... DONE
[17:28:18.448] Resolving globals: FALSE
[17:28:18.449] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.449] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.449] - globals: [1] 'x'
[17:28:18.450] 
[17:28:18.450] getGlobalsAndPackages() ... DONE
[17:28:18.450] run() for 'Future' ...
[17:28:18.450] - state: 'created'
[17:28:18.450] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.451] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.451] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.451]   - Field: 'label'
[17:28:18.451]   - Field: 'local'
[17:28:18.451]   - Field: 'owner'
[17:28:18.452]   - Field: 'envir'
[17:28:18.452]   - Field: 'packages'
[17:28:18.452]   - Field: 'gc'
[17:28:18.452]   - Field: 'conditions'
[17:28:18.452]   - Field: 'expr'
[17:28:18.453]   - Field: 'uuid'
[17:28:18.453]   - Field: 'seed'
[17:28:18.453]   - Field: 'version'
[17:28:18.453]   - Field: 'result'
[17:28:18.453]   - Field: 'asynchronous'
[17:28:18.453]   - Field: 'calls'
[17:28:18.454]   - Field: 'globals'
[17:28:18.454]   - Field: 'stdout'
[17:28:18.454]   - Field: 'earlySignal'
[17:28:18.454]   - Field: 'lazy'
[17:28:18.454]   - Field: 'state'
[17:28:18.454] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.455] - Launch lazy future ...
[17:28:18.455] Packages needed by the future expression (n = 0): <none>
[17:28:18.455] Packages needed by future strategies (n = 0): <none>
[17:28:18.456] {
[17:28:18.456]     {
[17:28:18.456]         {
[17:28:18.456]             ...future.startTime <- base::Sys.time()
[17:28:18.456]             {
[17:28:18.456]                 {
[17:28:18.456]                   {
[17:28:18.456]                     base::local({
[17:28:18.456]                       has_future <- base::requireNamespace("future", 
[17:28:18.456]                         quietly = TRUE)
[17:28:18.456]                       if (has_future) {
[17:28:18.456]                         ns <- base::getNamespace("future")
[17:28:18.456]                         version <- ns[[".package"]][["version"]]
[17:28:18.456]                         if (is.null(version)) 
[17:28:18.456]                           version <- utils::packageVersion("future")
[17:28:18.456]                       }
[17:28:18.456]                       else {
[17:28:18.456]                         version <- NULL
[17:28:18.456]                       }
[17:28:18.456]                       if (!has_future || version < "1.8.0") {
[17:28:18.456]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.456]                           "", base::R.version$version.string), 
[17:28:18.456]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.456]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.456]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.456]                             "release", "version")], collapse = " "), 
[17:28:18.456]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.456]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.456]                           info)
[17:28:18.456]                         info <- base::paste(info, collapse = "; ")
[17:28:18.456]                         if (!has_future) {
[17:28:18.456]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.456]                             info)
[17:28:18.456]                         }
[17:28:18.456]                         else {
[17:28:18.456]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.456]                             info, version)
[17:28:18.456]                         }
[17:28:18.456]                         base::stop(msg)
[17:28:18.456]                       }
[17:28:18.456]                     })
[17:28:18.456]                   }
[17:28:18.456]                   ...future.strategy.old <- future::plan("list")
[17:28:18.456]                   options(future.plan = NULL)
[17:28:18.456]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.456]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.456]                 }
[17:28:18.456]                 ...future.workdir <- getwd()
[17:28:18.456]             }
[17:28:18.456]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.456]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.456]         }
[17:28:18.456]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.456]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.456]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.456]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.456]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.456]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.456]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.456]             base::names(...future.oldOptions))
[17:28:18.456]     }
[17:28:18.456]     if (FALSE) {
[17:28:18.456]     }
[17:28:18.456]     else {
[17:28:18.456]         if (TRUE) {
[17:28:18.456]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.456]                 open = "w")
[17:28:18.456]         }
[17:28:18.456]         else {
[17:28:18.456]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.456]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.456]         }
[17:28:18.456]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.456]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.456]             base::sink(type = "output", split = FALSE)
[17:28:18.456]             base::close(...future.stdout)
[17:28:18.456]         }, add = TRUE)
[17:28:18.456]     }
[17:28:18.456]     ...future.frame <- base::sys.nframe()
[17:28:18.456]     ...future.conditions <- base::list()
[17:28:18.456]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.456]     if (FALSE) {
[17:28:18.456]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.456]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.456]     }
[17:28:18.456]     ...future.result <- base::tryCatch({
[17:28:18.456]         base::withCallingHandlers({
[17:28:18.456]             ...future.value <- base::withVisible(base::local({
[17:28:18.456]                 sample(x, size = 1L)
[17:28:18.456]             }))
[17:28:18.456]             future::FutureResult(value = ...future.value$value, 
[17:28:18.456]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.456]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.456]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.456]                     ...future.globalenv.names))
[17:28:18.456]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.456]         }, condition = base::local({
[17:28:18.456]             c <- base::c
[17:28:18.456]             inherits <- base::inherits
[17:28:18.456]             invokeRestart <- base::invokeRestart
[17:28:18.456]             length <- base::length
[17:28:18.456]             list <- base::list
[17:28:18.456]             seq.int <- base::seq.int
[17:28:18.456]             signalCondition <- base::signalCondition
[17:28:18.456]             sys.calls <- base::sys.calls
[17:28:18.456]             `[[` <- base::`[[`
[17:28:18.456]             `+` <- base::`+`
[17:28:18.456]             `<<-` <- base::`<<-`
[17:28:18.456]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.456]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.456]                   3L)]
[17:28:18.456]             }
[17:28:18.456]             function(cond) {
[17:28:18.456]                 is_error <- inherits(cond, "error")
[17:28:18.456]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.456]                   NULL)
[17:28:18.456]                 if (is_error) {
[17:28:18.456]                   sessionInformation <- function() {
[17:28:18.456]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.456]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.456]                       search = base::search(), system = base::Sys.info())
[17:28:18.456]                   }
[17:28:18.456]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.456]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.456]                     cond$call), session = sessionInformation(), 
[17:28:18.456]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.456]                   signalCondition(cond)
[17:28:18.456]                 }
[17:28:18.456]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.456]                 "immediateCondition"))) {
[17:28:18.456]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.456]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.456]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.456]                   if (TRUE && !signal) {
[17:28:18.456]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.456]                     {
[17:28:18.456]                       inherits <- base::inherits
[17:28:18.456]                       invokeRestart <- base::invokeRestart
[17:28:18.456]                       is.null <- base::is.null
[17:28:18.456]                       muffled <- FALSE
[17:28:18.456]                       if (inherits(cond, "message")) {
[17:28:18.456]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.456]                         if (muffled) 
[17:28:18.456]                           invokeRestart("muffleMessage")
[17:28:18.456]                       }
[17:28:18.456]                       else if (inherits(cond, "warning")) {
[17:28:18.456]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.456]                         if (muffled) 
[17:28:18.456]                           invokeRestart("muffleWarning")
[17:28:18.456]                       }
[17:28:18.456]                       else if (inherits(cond, "condition")) {
[17:28:18.456]                         if (!is.null(pattern)) {
[17:28:18.456]                           computeRestarts <- base::computeRestarts
[17:28:18.456]                           grepl <- base::grepl
[17:28:18.456]                           restarts <- computeRestarts(cond)
[17:28:18.456]                           for (restart in restarts) {
[17:28:18.456]                             name <- restart$name
[17:28:18.456]                             if (is.null(name)) 
[17:28:18.456]                               next
[17:28:18.456]                             if (!grepl(pattern, name)) 
[17:28:18.456]                               next
[17:28:18.456]                             invokeRestart(restart)
[17:28:18.456]                             muffled <- TRUE
[17:28:18.456]                             break
[17:28:18.456]                           }
[17:28:18.456]                         }
[17:28:18.456]                       }
[17:28:18.456]                       invisible(muffled)
[17:28:18.456]                     }
[17:28:18.456]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.456]                   }
[17:28:18.456]                 }
[17:28:18.456]                 else {
[17:28:18.456]                   if (TRUE) {
[17:28:18.456]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.456]                     {
[17:28:18.456]                       inherits <- base::inherits
[17:28:18.456]                       invokeRestart <- base::invokeRestart
[17:28:18.456]                       is.null <- base::is.null
[17:28:18.456]                       muffled <- FALSE
[17:28:18.456]                       if (inherits(cond, "message")) {
[17:28:18.456]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.456]                         if (muffled) 
[17:28:18.456]                           invokeRestart("muffleMessage")
[17:28:18.456]                       }
[17:28:18.456]                       else if (inherits(cond, "warning")) {
[17:28:18.456]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.456]                         if (muffled) 
[17:28:18.456]                           invokeRestart("muffleWarning")
[17:28:18.456]                       }
[17:28:18.456]                       else if (inherits(cond, "condition")) {
[17:28:18.456]                         if (!is.null(pattern)) {
[17:28:18.456]                           computeRestarts <- base::computeRestarts
[17:28:18.456]                           grepl <- base::grepl
[17:28:18.456]                           restarts <- computeRestarts(cond)
[17:28:18.456]                           for (restart in restarts) {
[17:28:18.456]                             name <- restart$name
[17:28:18.456]                             if (is.null(name)) 
[17:28:18.456]                               next
[17:28:18.456]                             if (!grepl(pattern, name)) 
[17:28:18.456]                               next
[17:28:18.456]                             invokeRestart(restart)
[17:28:18.456]                             muffled <- TRUE
[17:28:18.456]                             break
[17:28:18.456]                           }
[17:28:18.456]                         }
[17:28:18.456]                       }
[17:28:18.456]                       invisible(muffled)
[17:28:18.456]                     }
[17:28:18.456]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.456]                   }
[17:28:18.456]                 }
[17:28:18.456]             }
[17:28:18.456]         }))
[17:28:18.456]     }, error = function(ex) {
[17:28:18.456]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.456]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.456]                 ...future.rng), started = ...future.startTime, 
[17:28:18.456]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.456]             version = "1.8"), class = "FutureResult")
[17:28:18.456]     }, finally = {
[17:28:18.456]         if (!identical(...future.workdir, getwd())) 
[17:28:18.456]             setwd(...future.workdir)
[17:28:18.456]         {
[17:28:18.456]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.456]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.456]             }
[17:28:18.456]             base::options(...future.oldOptions)
[17:28:18.456]             if (.Platform$OS.type == "windows") {
[17:28:18.456]                 old_names <- names(...future.oldEnvVars)
[17:28:18.456]                 envs <- base::Sys.getenv()
[17:28:18.456]                 names <- names(envs)
[17:28:18.456]                 common <- intersect(names, old_names)
[17:28:18.456]                 added <- setdiff(names, old_names)
[17:28:18.456]                 removed <- setdiff(old_names, names)
[17:28:18.456]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.456]                   envs[common]]
[17:28:18.456]                 NAMES <- toupper(changed)
[17:28:18.456]                 args <- list()
[17:28:18.456]                 for (kk in seq_along(NAMES)) {
[17:28:18.456]                   name <- changed[[kk]]
[17:28:18.456]                   NAME <- NAMES[[kk]]
[17:28:18.456]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.456]                     next
[17:28:18.456]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.456]                 }
[17:28:18.456]                 NAMES <- toupper(added)
[17:28:18.456]                 for (kk in seq_along(NAMES)) {
[17:28:18.456]                   name <- added[[kk]]
[17:28:18.456]                   NAME <- NAMES[[kk]]
[17:28:18.456]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.456]                     next
[17:28:18.456]                   args[[name]] <- ""
[17:28:18.456]                 }
[17:28:18.456]                 NAMES <- toupper(removed)
[17:28:18.456]                 for (kk in seq_along(NAMES)) {
[17:28:18.456]                   name <- removed[[kk]]
[17:28:18.456]                   NAME <- NAMES[[kk]]
[17:28:18.456]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.456]                     next
[17:28:18.456]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.456]                 }
[17:28:18.456]                 if (length(args) > 0) 
[17:28:18.456]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.456]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.456]             }
[17:28:18.456]             else {
[17:28:18.456]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.456]             }
[17:28:18.456]             {
[17:28:18.456]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.456]                   0L) {
[17:28:18.456]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.456]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.456]                   base::options(opts)
[17:28:18.456]                 }
[17:28:18.456]                 {
[17:28:18.456]                   {
[17:28:18.456]                     base::assign(".Random.seed", c(10407L, 624480187L, 
[17:28:18.456]                     487568585L, -1953630238L, -708227568L, 1559387678L, 
[17:28:18.456]                     2078823719L), envir = base::globalenv(), 
[17:28:18.456]                       inherits = FALSE)
[17:28:18.456]                     NULL
[17:28:18.456]                   }
[17:28:18.456]                   options(future.plan = NULL)
[17:28:18.456]                   if (is.na(NA_character_)) 
[17:28:18.456]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.456]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.456]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.456]                     .init = FALSE)
[17:28:18.456]                 }
[17:28:18.456]             }
[17:28:18.456]         }
[17:28:18.456]     })
[17:28:18.456]     if (TRUE) {
[17:28:18.456]         base::sink(type = "output", split = FALSE)
[17:28:18.456]         if (TRUE) {
[17:28:18.456]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.456]         }
[17:28:18.456]         else {
[17:28:18.456]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.456]         }
[17:28:18.456]         base::close(...future.stdout)
[17:28:18.456]         ...future.stdout <- NULL
[17:28:18.456]     }
[17:28:18.456]     ...future.result$conditions <- ...future.conditions
[17:28:18.456]     ...future.result$finished <- base::Sys.time()
[17:28:18.456]     ...future.result
[17:28:18.456] }
[17:28:18.459] assign_globals() ...
[17:28:18.459] List of 1
[17:28:18.459]  $ x: int [1:4] 0 1 2 3
[17:28:18.459]  - attr(*, "where")=List of 1
[17:28:18.459]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.459]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.459]  - attr(*, "resolved")= logi FALSE
[17:28:18.459]  - attr(*, "total_size")= num 64
[17:28:18.459]  - attr(*, "already-done")= logi TRUE
[17:28:18.462] - copied 'x' to environment
[17:28:18.462] assign_globals() ... done
[17:28:18.463] plan(): Setting new future strategy stack:
[17:28:18.463] List of future strategies:
[17:28:18.463] 1. sequential:
[17:28:18.463]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.463]    - tweaked: FALSE
[17:28:18.463]    - call: NULL
[17:28:18.464] plan(): nbrOfWorkers() = 1
[17:28:18.465] plan(): Setting new future strategy stack:
[17:28:18.465] List of future strategies:
[17:28:18.465] 1. sequential:
[17:28:18.465]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.465]    - tweaked: FALSE
[17:28:18.465]    - call: plan(strategy)
[17:28:18.465] plan(): nbrOfWorkers() = 1
[17:28:18.466] SequentialFuture started (and completed)
[17:28:18.466] - Launch lazy future ... done
[17:28:18.466] run() for 'SequentialFuture' ... done
[[1]]
[1] 3

[[2]]
[1] 1

[[3]]
[1] 1

[[4]]
[1] 3

[17:28:18.467] getGlobalsAndPackages() ...
[17:28:18.467] Searching for globals...
[17:28:18.468] - globals found: [3] '{', 'sample', 'x'
[17:28:18.469] Searching for globals ... DONE
[17:28:18.469] Resolving globals: FALSE
[17:28:18.469] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.470] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.470] - globals: [1] 'x'
[17:28:18.470] 
[17:28:18.470] getGlobalsAndPackages() ... DONE
[17:28:18.471] run() for 'Future' ...
[17:28:18.471] - state: 'created'
[17:28:18.471] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.471] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.471] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.472]   - Field: 'label'
[17:28:18.472]   - Field: 'local'
[17:28:18.472]   - Field: 'owner'
[17:28:18.472]   - Field: 'envir'
[17:28:18.472]   - Field: 'packages'
[17:28:18.473]   - Field: 'gc'
[17:28:18.473]   - Field: 'conditions'
[17:28:18.473]   - Field: 'expr'
[17:28:18.473]   - Field: 'uuid'
[17:28:18.473]   - Field: 'seed'
[17:28:18.473]   - Field: 'version'
[17:28:18.474]   - Field: 'result'
[17:28:18.474]   - Field: 'asynchronous'
[17:28:18.474]   - Field: 'calls'
[17:28:18.474]   - Field: 'globals'
[17:28:18.474]   - Field: 'stdout'
[17:28:18.474]   - Field: 'earlySignal'
[17:28:18.475]   - Field: 'lazy'
[17:28:18.475]   - Field: 'state'
[17:28:18.475] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.475] - Launch lazy future ...
[17:28:18.475] Packages needed by the future expression (n = 0): <none>
[17:28:18.476] Packages needed by future strategies (n = 0): <none>
[17:28:18.476] {
[17:28:18.476]     {
[17:28:18.476]         {
[17:28:18.476]             ...future.startTime <- base::Sys.time()
[17:28:18.476]             {
[17:28:18.476]                 {
[17:28:18.476]                   {
[17:28:18.476]                     base::local({
[17:28:18.476]                       has_future <- base::requireNamespace("future", 
[17:28:18.476]                         quietly = TRUE)
[17:28:18.476]                       if (has_future) {
[17:28:18.476]                         ns <- base::getNamespace("future")
[17:28:18.476]                         version <- ns[[".package"]][["version"]]
[17:28:18.476]                         if (is.null(version)) 
[17:28:18.476]                           version <- utils::packageVersion("future")
[17:28:18.476]                       }
[17:28:18.476]                       else {
[17:28:18.476]                         version <- NULL
[17:28:18.476]                       }
[17:28:18.476]                       if (!has_future || version < "1.8.0") {
[17:28:18.476]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.476]                           "", base::R.version$version.string), 
[17:28:18.476]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.476]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.476]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.476]                             "release", "version")], collapse = " "), 
[17:28:18.476]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.476]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.476]                           info)
[17:28:18.476]                         info <- base::paste(info, collapse = "; ")
[17:28:18.476]                         if (!has_future) {
[17:28:18.476]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.476]                             info)
[17:28:18.476]                         }
[17:28:18.476]                         else {
[17:28:18.476]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.476]                             info, version)
[17:28:18.476]                         }
[17:28:18.476]                         base::stop(msg)
[17:28:18.476]                       }
[17:28:18.476]                     })
[17:28:18.476]                   }
[17:28:18.476]                   ...future.strategy.old <- future::plan("list")
[17:28:18.476]                   options(future.plan = NULL)
[17:28:18.476]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.476]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.476]                 }
[17:28:18.476]                 ...future.workdir <- getwd()
[17:28:18.476]             }
[17:28:18.476]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.476]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.476]         }
[17:28:18.476]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.476]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.476]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.476]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.476]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.476]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.476]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.476]             base::names(...future.oldOptions))
[17:28:18.476]     }
[17:28:18.476]     if (FALSE) {
[17:28:18.476]     }
[17:28:18.476]     else {
[17:28:18.476]         if (TRUE) {
[17:28:18.476]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.476]                 open = "w")
[17:28:18.476]         }
[17:28:18.476]         else {
[17:28:18.476]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.476]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.476]         }
[17:28:18.476]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.476]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.476]             base::sink(type = "output", split = FALSE)
[17:28:18.476]             base::close(...future.stdout)
[17:28:18.476]         }, add = TRUE)
[17:28:18.476]     }
[17:28:18.476]     ...future.frame <- base::sys.nframe()
[17:28:18.476]     ...future.conditions <- base::list()
[17:28:18.476]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.476]     if (FALSE) {
[17:28:18.476]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.476]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.476]     }
[17:28:18.476]     ...future.result <- base::tryCatch({
[17:28:18.476]         base::withCallingHandlers({
[17:28:18.476]             ...future.value <- base::withVisible(base::local({
[17:28:18.476]                 sample(x, size = 1L)
[17:28:18.476]             }))
[17:28:18.476]             future::FutureResult(value = ...future.value$value, 
[17:28:18.476]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.476]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.476]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.476]                     ...future.globalenv.names))
[17:28:18.476]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.476]         }, condition = base::local({
[17:28:18.476]             c <- base::c
[17:28:18.476]             inherits <- base::inherits
[17:28:18.476]             invokeRestart <- base::invokeRestart
[17:28:18.476]             length <- base::length
[17:28:18.476]             list <- base::list
[17:28:18.476]             seq.int <- base::seq.int
[17:28:18.476]             signalCondition <- base::signalCondition
[17:28:18.476]             sys.calls <- base::sys.calls
[17:28:18.476]             `[[` <- base::`[[`
[17:28:18.476]             `+` <- base::`+`
[17:28:18.476]             `<<-` <- base::`<<-`
[17:28:18.476]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.476]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.476]                   3L)]
[17:28:18.476]             }
[17:28:18.476]             function(cond) {
[17:28:18.476]                 is_error <- inherits(cond, "error")
[17:28:18.476]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.476]                   NULL)
[17:28:18.476]                 if (is_error) {
[17:28:18.476]                   sessionInformation <- function() {
[17:28:18.476]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.476]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.476]                       search = base::search(), system = base::Sys.info())
[17:28:18.476]                   }
[17:28:18.476]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.476]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.476]                     cond$call), session = sessionInformation(), 
[17:28:18.476]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.476]                   signalCondition(cond)
[17:28:18.476]                 }
[17:28:18.476]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.476]                 "immediateCondition"))) {
[17:28:18.476]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.476]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.476]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.476]                   if (TRUE && !signal) {
[17:28:18.476]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.476]                     {
[17:28:18.476]                       inherits <- base::inherits
[17:28:18.476]                       invokeRestart <- base::invokeRestart
[17:28:18.476]                       is.null <- base::is.null
[17:28:18.476]                       muffled <- FALSE
[17:28:18.476]                       if (inherits(cond, "message")) {
[17:28:18.476]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.476]                         if (muffled) 
[17:28:18.476]                           invokeRestart("muffleMessage")
[17:28:18.476]                       }
[17:28:18.476]                       else if (inherits(cond, "warning")) {
[17:28:18.476]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.476]                         if (muffled) 
[17:28:18.476]                           invokeRestart("muffleWarning")
[17:28:18.476]                       }
[17:28:18.476]                       else if (inherits(cond, "condition")) {
[17:28:18.476]                         if (!is.null(pattern)) {
[17:28:18.476]                           computeRestarts <- base::computeRestarts
[17:28:18.476]                           grepl <- base::grepl
[17:28:18.476]                           restarts <- computeRestarts(cond)
[17:28:18.476]                           for (restart in restarts) {
[17:28:18.476]                             name <- restart$name
[17:28:18.476]                             if (is.null(name)) 
[17:28:18.476]                               next
[17:28:18.476]                             if (!grepl(pattern, name)) 
[17:28:18.476]                               next
[17:28:18.476]                             invokeRestart(restart)
[17:28:18.476]                             muffled <- TRUE
[17:28:18.476]                             break
[17:28:18.476]                           }
[17:28:18.476]                         }
[17:28:18.476]                       }
[17:28:18.476]                       invisible(muffled)
[17:28:18.476]                     }
[17:28:18.476]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.476]                   }
[17:28:18.476]                 }
[17:28:18.476]                 else {
[17:28:18.476]                   if (TRUE) {
[17:28:18.476]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.476]                     {
[17:28:18.476]                       inherits <- base::inherits
[17:28:18.476]                       invokeRestart <- base::invokeRestart
[17:28:18.476]                       is.null <- base::is.null
[17:28:18.476]                       muffled <- FALSE
[17:28:18.476]                       if (inherits(cond, "message")) {
[17:28:18.476]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.476]                         if (muffled) 
[17:28:18.476]                           invokeRestart("muffleMessage")
[17:28:18.476]                       }
[17:28:18.476]                       else if (inherits(cond, "warning")) {
[17:28:18.476]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.476]                         if (muffled) 
[17:28:18.476]                           invokeRestart("muffleWarning")
[17:28:18.476]                       }
[17:28:18.476]                       else if (inherits(cond, "condition")) {
[17:28:18.476]                         if (!is.null(pattern)) {
[17:28:18.476]                           computeRestarts <- base::computeRestarts
[17:28:18.476]                           grepl <- base::grepl
[17:28:18.476]                           restarts <- computeRestarts(cond)
[17:28:18.476]                           for (restart in restarts) {
[17:28:18.476]                             name <- restart$name
[17:28:18.476]                             if (is.null(name)) 
[17:28:18.476]                               next
[17:28:18.476]                             if (!grepl(pattern, name)) 
[17:28:18.476]                               next
[17:28:18.476]                             invokeRestart(restart)
[17:28:18.476]                             muffled <- TRUE
[17:28:18.476]                             break
[17:28:18.476]                           }
[17:28:18.476]                         }
[17:28:18.476]                       }
[17:28:18.476]                       invisible(muffled)
[17:28:18.476]                     }
[17:28:18.476]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.476]                   }
[17:28:18.476]                 }
[17:28:18.476]             }
[17:28:18.476]         }))
[17:28:18.476]     }, error = function(ex) {
[17:28:18.476]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.476]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.476]                 ...future.rng), started = ...future.startTime, 
[17:28:18.476]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.476]             version = "1.8"), class = "FutureResult")
[17:28:18.476]     }, finally = {
[17:28:18.476]         if (!identical(...future.workdir, getwd())) 
[17:28:18.476]             setwd(...future.workdir)
[17:28:18.476]         {
[17:28:18.476]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.476]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.476]             }
[17:28:18.476]             base::options(...future.oldOptions)
[17:28:18.476]             if (.Platform$OS.type == "windows") {
[17:28:18.476]                 old_names <- names(...future.oldEnvVars)
[17:28:18.476]                 envs <- base::Sys.getenv()
[17:28:18.476]                 names <- names(envs)
[17:28:18.476]                 common <- intersect(names, old_names)
[17:28:18.476]                 added <- setdiff(names, old_names)
[17:28:18.476]                 removed <- setdiff(old_names, names)
[17:28:18.476]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.476]                   envs[common]]
[17:28:18.476]                 NAMES <- toupper(changed)
[17:28:18.476]                 args <- list()
[17:28:18.476]                 for (kk in seq_along(NAMES)) {
[17:28:18.476]                   name <- changed[[kk]]
[17:28:18.476]                   NAME <- NAMES[[kk]]
[17:28:18.476]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.476]                     next
[17:28:18.476]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.476]                 }
[17:28:18.476]                 NAMES <- toupper(added)
[17:28:18.476]                 for (kk in seq_along(NAMES)) {
[17:28:18.476]                   name <- added[[kk]]
[17:28:18.476]                   NAME <- NAMES[[kk]]
[17:28:18.476]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.476]                     next
[17:28:18.476]                   args[[name]] <- ""
[17:28:18.476]                 }
[17:28:18.476]                 NAMES <- toupper(removed)
[17:28:18.476]                 for (kk in seq_along(NAMES)) {
[17:28:18.476]                   name <- removed[[kk]]
[17:28:18.476]                   NAME <- NAMES[[kk]]
[17:28:18.476]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.476]                     next
[17:28:18.476]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.476]                 }
[17:28:18.476]                 if (length(args) > 0) 
[17:28:18.476]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.476]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.476]             }
[17:28:18.476]             else {
[17:28:18.476]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.476]             }
[17:28:18.476]             {
[17:28:18.476]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.476]                   0L) {
[17:28:18.476]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.476]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.476]                   base::options(opts)
[17:28:18.476]                 }
[17:28:18.476]                 {
[17:28:18.476]                   {
[17:28:18.476]                     base::assign(".Random.seed", c(10407L, -1877357164L, 
[17:28:18.476]                     1962747760L, 696435396L, -889451493L, 1368934459L, 
[17:28:18.476]                     1433489833L), envir = base::globalenv(), 
[17:28:18.476]                       inherits = FALSE)
[17:28:18.476]                     NULL
[17:28:18.476]                   }
[17:28:18.476]                   options(future.plan = NULL)
[17:28:18.476]                   if (is.na(NA_character_)) 
[17:28:18.476]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.476]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.476]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.476]                     .init = FALSE)
[17:28:18.476]                 }
[17:28:18.476]             }
[17:28:18.476]         }
[17:28:18.476]     })
[17:28:18.476]     if (TRUE) {
[17:28:18.476]         base::sink(type = "output", split = FALSE)
[17:28:18.476]         if (TRUE) {
[17:28:18.476]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.476]         }
[17:28:18.476]         else {
[17:28:18.476]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.476]         }
[17:28:18.476]         base::close(...future.stdout)
[17:28:18.476]         ...future.stdout <- NULL
[17:28:18.476]     }
[17:28:18.476]     ...future.result$conditions <- ...future.conditions
[17:28:18.476]     ...future.result$finished <- base::Sys.time()
[17:28:18.476]     ...future.result
[17:28:18.476] }
[17:28:18.480] assign_globals() ...
[17:28:18.481] List of 1
[17:28:18.481]  $ x: int [1:4] 0 1 2 3
[17:28:18.481]  - attr(*, "where")=List of 1
[17:28:18.481]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.481]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.481]  - attr(*, "resolved")= logi FALSE
[17:28:18.481]  - attr(*, "total_size")= num 64
[17:28:18.481]  - attr(*, "already-done")= logi TRUE
[17:28:18.484] - copied 'x' to environment
[17:28:18.484] assign_globals() ... done
[17:28:18.485] plan(): Setting new future strategy stack:
[17:28:18.485] List of future strategies:
[17:28:18.485] 1. sequential:
[17:28:18.485]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.485]    - tweaked: FALSE
[17:28:18.485]    - call: NULL
[17:28:18.485] plan(): nbrOfWorkers() = 1
[17:28:18.486] plan(): Setting new future strategy stack:
[17:28:18.487] List of future strategies:
[17:28:18.487] 1. sequential:
[17:28:18.487]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.487]    - tweaked: FALSE
[17:28:18.487]    - call: plan(strategy)
[17:28:18.487] plan(): nbrOfWorkers() = 1
[17:28:18.487] SequentialFuture started (and completed)
[17:28:18.488] - Launch lazy future ... done
[17:28:18.488] run() for 'SequentialFuture' ... done
[17:28:18.488] getGlobalsAndPackages() ...
[17:28:18.489] Searching for globals...
[17:28:18.490] - globals found: [3] '{', 'sample', 'x'
[17:28:18.490] Searching for globals ... DONE
[17:28:18.490] Resolving globals: FALSE
[17:28:18.490] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.491] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.491] - globals: [1] 'x'
[17:28:18.491] 
[17:28:18.491] getGlobalsAndPackages() ... DONE
[17:28:18.492] run() for 'Future' ...
[17:28:18.492] - state: 'created'
[17:28:18.492] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.492] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.493] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.493]   - Field: 'label'
[17:28:18.493]   - Field: 'local'
[17:28:18.493]   - Field: 'owner'
[17:28:18.493]   - Field: 'envir'
[17:28:18.494]   - Field: 'packages'
[17:28:18.494]   - Field: 'gc'
[17:28:18.494]   - Field: 'conditions'
[17:28:18.494]   - Field: 'expr'
[17:28:18.494]   - Field: 'uuid'
[17:28:18.494]   - Field: 'seed'
[17:28:18.495]   - Field: 'version'
[17:28:18.495]   - Field: 'result'
[17:28:18.495]   - Field: 'asynchronous'
[17:28:18.495]   - Field: 'calls'
[17:28:18.495]   - Field: 'globals'
[17:28:18.495]   - Field: 'stdout'
[17:28:18.496]   - Field: 'earlySignal'
[17:28:18.496]   - Field: 'lazy'
[17:28:18.496]   - Field: 'state'
[17:28:18.496] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.496] - Launch lazy future ...
[17:28:18.497] Packages needed by the future expression (n = 0): <none>
[17:28:18.497] Packages needed by future strategies (n = 0): <none>
[17:28:18.497] {
[17:28:18.497]     {
[17:28:18.497]         {
[17:28:18.497]             ...future.startTime <- base::Sys.time()
[17:28:18.497]             {
[17:28:18.497]                 {
[17:28:18.497]                   {
[17:28:18.497]                     base::local({
[17:28:18.497]                       has_future <- base::requireNamespace("future", 
[17:28:18.497]                         quietly = TRUE)
[17:28:18.497]                       if (has_future) {
[17:28:18.497]                         ns <- base::getNamespace("future")
[17:28:18.497]                         version <- ns[[".package"]][["version"]]
[17:28:18.497]                         if (is.null(version)) 
[17:28:18.497]                           version <- utils::packageVersion("future")
[17:28:18.497]                       }
[17:28:18.497]                       else {
[17:28:18.497]                         version <- NULL
[17:28:18.497]                       }
[17:28:18.497]                       if (!has_future || version < "1.8.0") {
[17:28:18.497]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.497]                           "", base::R.version$version.string), 
[17:28:18.497]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.497]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.497]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.497]                             "release", "version")], collapse = " "), 
[17:28:18.497]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.497]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.497]                           info)
[17:28:18.497]                         info <- base::paste(info, collapse = "; ")
[17:28:18.497]                         if (!has_future) {
[17:28:18.497]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.497]                             info)
[17:28:18.497]                         }
[17:28:18.497]                         else {
[17:28:18.497]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.497]                             info, version)
[17:28:18.497]                         }
[17:28:18.497]                         base::stop(msg)
[17:28:18.497]                       }
[17:28:18.497]                     })
[17:28:18.497]                   }
[17:28:18.497]                   ...future.strategy.old <- future::plan("list")
[17:28:18.497]                   options(future.plan = NULL)
[17:28:18.497]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.497]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.497]                 }
[17:28:18.497]                 ...future.workdir <- getwd()
[17:28:18.497]             }
[17:28:18.497]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.497]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.497]         }
[17:28:18.497]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.497]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.497]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.497]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.497]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.497]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.497]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.497]             base::names(...future.oldOptions))
[17:28:18.497]     }
[17:28:18.497]     if (FALSE) {
[17:28:18.497]     }
[17:28:18.497]     else {
[17:28:18.497]         if (TRUE) {
[17:28:18.497]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.497]                 open = "w")
[17:28:18.497]         }
[17:28:18.497]         else {
[17:28:18.497]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.497]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.497]         }
[17:28:18.497]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.497]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.497]             base::sink(type = "output", split = FALSE)
[17:28:18.497]             base::close(...future.stdout)
[17:28:18.497]         }, add = TRUE)
[17:28:18.497]     }
[17:28:18.497]     ...future.frame <- base::sys.nframe()
[17:28:18.497]     ...future.conditions <- base::list()
[17:28:18.497]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.497]     if (FALSE) {
[17:28:18.497]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.497]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.497]     }
[17:28:18.497]     ...future.result <- base::tryCatch({
[17:28:18.497]         base::withCallingHandlers({
[17:28:18.497]             ...future.value <- base::withVisible(base::local({
[17:28:18.497]                 sample(x, size = 1L)
[17:28:18.497]             }))
[17:28:18.497]             future::FutureResult(value = ...future.value$value, 
[17:28:18.497]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.497]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.497]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.497]                     ...future.globalenv.names))
[17:28:18.497]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.497]         }, condition = base::local({
[17:28:18.497]             c <- base::c
[17:28:18.497]             inherits <- base::inherits
[17:28:18.497]             invokeRestart <- base::invokeRestart
[17:28:18.497]             length <- base::length
[17:28:18.497]             list <- base::list
[17:28:18.497]             seq.int <- base::seq.int
[17:28:18.497]             signalCondition <- base::signalCondition
[17:28:18.497]             sys.calls <- base::sys.calls
[17:28:18.497]             `[[` <- base::`[[`
[17:28:18.497]             `+` <- base::`+`
[17:28:18.497]             `<<-` <- base::`<<-`
[17:28:18.497]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.497]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.497]                   3L)]
[17:28:18.497]             }
[17:28:18.497]             function(cond) {
[17:28:18.497]                 is_error <- inherits(cond, "error")
[17:28:18.497]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.497]                   NULL)
[17:28:18.497]                 if (is_error) {
[17:28:18.497]                   sessionInformation <- function() {
[17:28:18.497]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.497]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.497]                       search = base::search(), system = base::Sys.info())
[17:28:18.497]                   }
[17:28:18.497]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.497]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.497]                     cond$call), session = sessionInformation(), 
[17:28:18.497]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.497]                   signalCondition(cond)
[17:28:18.497]                 }
[17:28:18.497]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.497]                 "immediateCondition"))) {
[17:28:18.497]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.497]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.497]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.497]                   if (TRUE && !signal) {
[17:28:18.497]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.497]                     {
[17:28:18.497]                       inherits <- base::inherits
[17:28:18.497]                       invokeRestart <- base::invokeRestart
[17:28:18.497]                       is.null <- base::is.null
[17:28:18.497]                       muffled <- FALSE
[17:28:18.497]                       if (inherits(cond, "message")) {
[17:28:18.497]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.497]                         if (muffled) 
[17:28:18.497]                           invokeRestart("muffleMessage")
[17:28:18.497]                       }
[17:28:18.497]                       else if (inherits(cond, "warning")) {
[17:28:18.497]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.497]                         if (muffled) 
[17:28:18.497]                           invokeRestart("muffleWarning")
[17:28:18.497]                       }
[17:28:18.497]                       else if (inherits(cond, "condition")) {
[17:28:18.497]                         if (!is.null(pattern)) {
[17:28:18.497]                           computeRestarts <- base::computeRestarts
[17:28:18.497]                           grepl <- base::grepl
[17:28:18.497]                           restarts <- computeRestarts(cond)
[17:28:18.497]                           for (restart in restarts) {
[17:28:18.497]                             name <- restart$name
[17:28:18.497]                             if (is.null(name)) 
[17:28:18.497]                               next
[17:28:18.497]                             if (!grepl(pattern, name)) 
[17:28:18.497]                               next
[17:28:18.497]                             invokeRestart(restart)
[17:28:18.497]                             muffled <- TRUE
[17:28:18.497]                             break
[17:28:18.497]                           }
[17:28:18.497]                         }
[17:28:18.497]                       }
[17:28:18.497]                       invisible(muffled)
[17:28:18.497]                     }
[17:28:18.497]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.497]                   }
[17:28:18.497]                 }
[17:28:18.497]                 else {
[17:28:18.497]                   if (TRUE) {
[17:28:18.497]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.497]                     {
[17:28:18.497]                       inherits <- base::inherits
[17:28:18.497]                       invokeRestart <- base::invokeRestart
[17:28:18.497]                       is.null <- base::is.null
[17:28:18.497]                       muffled <- FALSE
[17:28:18.497]                       if (inherits(cond, "message")) {
[17:28:18.497]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.497]                         if (muffled) 
[17:28:18.497]                           invokeRestart("muffleMessage")
[17:28:18.497]                       }
[17:28:18.497]                       else if (inherits(cond, "warning")) {
[17:28:18.497]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.497]                         if (muffled) 
[17:28:18.497]                           invokeRestart("muffleWarning")
[17:28:18.497]                       }
[17:28:18.497]                       else if (inherits(cond, "condition")) {
[17:28:18.497]                         if (!is.null(pattern)) {
[17:28:18.497]                           computeRestarts <- base::computeRestarts
[17:28:18.497]                           grepl <- base::grepl
[17:28:18.497]                           restarts <- computeRestarts(cond)
[17:28:18.497]                           for (restart in restarts) {
[17:28:18.497]                             name <- restart$name
[17:28:18.497]                             if (is.null(name)) 
[17:28:18.497]                               next
[17:28:18.497]                             if (!grepl(pattern, name)) 
[17:28:18.497]                               next
[17:28:18.497]                             invokeRestart(restart)
[17:28:18.497]                             muffled <- TRUE
[17:28:18.497]                             break
[17:28:18.497]                           }
[17:28:18.497]                         }
[17:28:18.497]                       }
[17:28:18.497]                       invisible(muffled)
[17:28:18.497]                     }
[17:28:18.497]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.497]                   }
[17:28:18.497]                 }
[17:28:18.497]             }
[17:28:18.497]         }))
[17:28:18.497]     }, error = function(ex) {
[17:28:18.497]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.497]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.497]                 ...future.rng), started = ...future.startTime, 
[17:28:18.497]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.497]             version = "1.8"), class = "FutureResult")
[17:28:18.497]     }, finally = {
[17:28:18.497]         if (!identical(...future.workdir, getwd())) 
[17:28:18.497]             setwd(...future.workdir)
[17:28:18.497]         {
[17:28:18.497]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.497]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.497]             }
[17:28:18.497]             base::options(...future.oldOptions)
[17:28:18.497]             if (.Platform$OS.type == "windows") {
[17:28:18.497]                 old_names <- names(...future.oldEnvVars)
[17:28:18.497]                 envs <- base::Sys.getenv()
[17:28:18.497]                 names <- names(envs)
[17:28:18.497]                 common <- intersect(names, old_names)
[17:28:18.497]                 added <- setdiff(names, old_names)
[17:28:18.497]                 removed <- setdiff(old_names, names)
[17:28:18.497]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.497]                   envs[common]]
[17:28:18.497]                 NAMES <- toupper(changed)
[17:28:18.497]                 args <- list()
[17:28:18.497]                 for (kk in seq_along(NAMES)) {
[17:28:18.497]                   name <- changed[[kk]]
[17:28:18.497]                   NAME <- NAMES[[kk]]
[17:28:18.497]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.497]                     next
[17:28:18.497]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.497]                 }
[17:28:18.497]                 NAMES <- toupper(added)
[17:28:18.497]                 for (kk in seq_along(NAMES)) {
[17:28:18.497]                   name <- added[[kk]]
[17:28:18.497]                   NAME <- NAMES[[kk]]
[17:28:18.497]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.497]                     next
[17:28:18.497]                   args[[name]] <- ""
[17:28:18.497]                 }
[17:28:18.497]                 NAMES <- toupper(removed)
[17:28:18.497]                 for (kk in seq_along(NAMES)) {
[17:28:18.497]                   name <- removed[[kk]]
[17:28:18.497]                   NAME <- NAMES[[kk]]
[17:28:18.497]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.497]                     next
[17:28:18.497]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.497]                 }
[17:28:18.497]                 if (length(args) > 0) 
[17:28:18.497]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.497]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.497]             }
[17:28:18.497]             else {
[17:28:18.497]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.497]             }
[17:28:18.497]             {
[17:28:18.497]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.497]                   0L) {
[17:28:18.497]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.497]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.497]                   base::options(opts)
[17:28:18.497]                 }
[17:28:18.497]                 {
[17:28:18.497]                   {
[17:28:18.497]                     base::assign(".Random.seed", c(10407L, 696435396L, 
[17:28:18.497]                     1189929049L, -976119509L, 1433489833L, -1954709644L, 
[17:28:18.497]                     -1294011257L), envir = base::globalenv(), 
[17:28:18.497]                       inherits = FALSE)
[17:28:18.497]                     NULL
[17:28:18.497]                   }
[17:28:18.497]                   options(future.plan = NULL)
[17:28:18.497]                   if (is.na(NA_character_)) 
[17:28:18.497]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.497]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.497]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.497]                     .init = FALSE)
[17:28:18.497]                 }
[17:28:18.497]             }
[17:28:18.497]         }
[17:28:18.497]     })
[17:28:18.497]     if (TRUE) {
[17:28:18.497]         base::sink(type = "output", split = FALSE)
[17:28:18.497]         if (TRUE) {
[17:28:18.497]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.497]         }
[17:28:18.497]         else {
[17:28:18.497]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.497]         }
[17:28:18.497]         base::close(...future.stdout)
[17:28:18.497]         ...future.stdout <- NULL
[17:28:18.497]     }
[17:28:18.497]     ...future.result$conditions <- ...future.conditions
[17:28:18.497]     ...future.result$finished <- base::Sys.time()
[17:28:18.497]     ...future.result
[17:28:18.497] }
[17:28:18.501] assign_globals() ...
[17:28:18.501] List of 1
[17:28:18.501]  $ x: int [1:4] 0 1 2 3
[17:28:18.501]  - attr(*, "where")=List of 1
[17:28:18.501]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.501]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.501]  - attr(*, "resolved")= logi FALSE
[17:28:18.501]  - attr(*, "total_size")= num 64
[17:28:18.501]  - attr(*, "already-done")= logi TRUE
[17:28:18.504] - copied 'x' to environment
[17:28:18.504] assign_globals() ... done
[17:28:18.505] plan(): Setting new future strategy stack:
[17:28:18.505] List of future strategies:
[17:28:18.505] 1. sequential:
[17:28:18.505]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.505]    - tweaked: FALSE
[17:28:18.505]    - call: NULL
[17:28:18.505] plan(): nbrOfWorkers() = 1
[17:28:18.507] plan(): Setting new future strategy stack:
[17:28:18.507] List of future strategies:
[17:28:18.507] 1. sequential:
[17:28:18.507]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.507]    - tweaked: FALSE
[17:28:18.507]    - call: plan(strategy)
[17:28:18.507] plan(): nbrOfWorkers() = 1
[17:28:18.508] SequentialFuture started (and completed)
[17:28:18.508] - Launch lazy future ... done
[17:28:18.508] run() for 'SequentialFuture' ... done
[17:28:18.509] getGlobalsAndPackages() ...
[17:28:18.510] Searching for globals...
[17:28:18.511] - globals found: [3] '{', 'sample', 'x'
[17:28:18.511] Searching for globals ... DONE
[17:28:18.511] Resolving globals: FALSE
[17:28:18.512] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.512] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.512] - globals: [1] 'x'
[17:28:18.512] 
[17:28:18.513] getGlobalsAndPackages() ... DONE
[17:28:18.513] run() for 'Future' ...
[17:28:18.513] - state: 'created'
[17:28:18.513] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.514] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.514] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.514]   - Field: 'label'
[17:28:18.514]   - Field: 'local'
[17:28:18.514]   - Field: 'owner'
[17:28:18.515]   - Field: 'envir'
[17:28:18.515]   - Field: 'packages'
[17:28:18.515]   - Field: 'gc'
[17:28:18.515]   - Field: 'conditions'
[17:28:18.515]   - Field: 'expr'
[17:28:18.515]   - Field: 'uuid'
[17:28:18.516]   - Field: 'seed'
[17:28:18.516]   - Field: 'version'
[17:28:18.516]   - Field: 'result'
[17:28:18.516]   - Field: 'asynchronous'
[17:28:18.516]   - Field: 'calls'
[17:28:18.516]   - Field: 'globals'
[17:28:18.517]   - Field: 'stdout'
[17:28:18.517]   - Field: 'earlySignal'
[17:28:18.517]   - Field: 'lazy'
[17:28:18.517]   - Field: 'state'
[17:28:18.517] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.518] - Launch lazy future ...
[17:28:18.518] Packages needed by the future expression (n = 0): <none>
[17:28:18.518] Packages needed by future strategies (n = 0): <none>
[17:28:18.518] {
[17:28:18.518]     {
[17:28:18.518]         {
[17:28:18.518]             ...future.startTime <- base::Sys.time()
[17:28:18.518]             {
[17:28:18.518]                 {
[17:28:18.518]                   {
[17:28:18.518]                     base::local({
[17:28:18.518]                       has_future <- base::requireNamespace("future", 
[17:28:18.518]                         quietly = TRUE)
[17:28:18.518]                       if (has_future) {
[17:28:18.518]                         ns <- base::getNamespace("future")
[17:28:18.518]                         version <- ns[[".package"]][["version"]]
[17:28:18.518]                         if (is.null(version)) 
[17:28:18.518]                           version <- utils::packageVersion("future")
[17:28:18.518]                       }
[17:28:18.518]                       else {
[17:28:18.518]                         version <- NULL
[17:28:18.518]                       }
[17:28:18.518]                       if (!has_future || version < "1.8.0") {
[17:28:18.518]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.518]                           "", base::R.version$version.string), 
[17:28:18.518]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.518]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.518]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.518]                             "release", "version")], collapse = " "), 
[17:28:18.518]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.518]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.518]                           info)
[17:28:18.518]                         info <- base::paste(info, collapse = "; ")
[17:28:18.518]                         if (!has_future) {
[17:28:18.518]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.518]                             info)
[17:28:18.518]                         }
[17:28:18.518]                         else {
[17:28:18.518]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.518]                             info, version)
[17:28:18.518]                         }
[17:28:18.518]                         base::stop(msg)
[17:28:18.518]                       }
[17:28:18.518]                     })
[17:28:18.518]                   }
[17:28:18.518]                   ...future.strategy.old <- future::plan("list")
[17:28:18.518]                   options(future.plan = NULL)
[17:28:18.518]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.518]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.518]                 }
[17:28:18.518]                 ...future.workdir <- getwd()
[17:28:18.518]             }
[17:28:18.518]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.518]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.518]         }
[17:28:18.518]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.518]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.518]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.518]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.518]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.518]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.518]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.518]             base::names(...future.oldOptions))
[17:28:18.518]     }
[17:28:18.518]     if (FALSE) {
[17:28:18.518]     }
[17:28:18.518]     else {
[17:28:18.518]         if (TRUE) {
[17:28:18.518]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.518]                 open = "w")
[17:28:18.518]         }
[17:28:18.518]         else {
[17:28:18.518]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.518]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.518]         }
[17:28:18.518]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.518]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.518]             base::sink(type = "output", split = FALSE)
[17:28:18.518]             base::close(...future.stdout)
[17:28:18.518]         }, add = TRUE)
[17:28:18.518]     }
[17:28:18.518]     ...future.frame <- base::sys.nframe()
[17:28:18.518]     ...future.conditions <- base::list()
[17:28:18.518]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.518]     if (FALSE) {
[17:28:18.518]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.518]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.518]     }
[17:28:18.518]     ...future.result <- base::tryCatch({
[17:28:18.518]         base::withCallingHandlers({
[17:28:18.518]             ...future.value <- base::withVisible(base::local({
[17:28:18.518]                 sample(x, size = 1L)
[17:28:18.518]             }))
[17:28:18.518]             future::FutureResult(value = ...future.value$value, 
[17:28:18.518]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.518]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.518]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.518]                     ...future.globalenv.names))
[17:28:18.518]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.518]         }, condition = base::local({
[17:28:18.518]             c <- base::c
[17:28:18.518]             inherits <- base::inherits
[17:28:18.518]             invokeRestart <- base::invokeRestart
[17:28:18.518]             length <- base::length
[17:28:18.518]             list <- base::list
[17:28:18.518]             seq.int <- base::seq.int
[17:28:18.518]             signalCondition <- base::signalCondition
[17:28:18.518]             sys.calls <- base::sys.calls
[17:28:18.518]             `[[` <- base::`[[`
[17:28:18.518]             `+` <- base::`+`
[17:28:18.518]             `<<-` <- base::`<<-`
[17:28:18.518]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.518]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.518]                   3L)]
[17:28:18.518]             }
[17:28:18.518]             function(cond) {
[17:28:18.518]                 is_error <- inherits(cond, "error")
[17:28:18.518]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.518]                   NULL)
[17:28:18.518]                 if (is_error) {
[17:28:18.518]                   sessionInformation <- function() {
[17:28:18.518]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.518]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.518]                       search = base::search(), system = base::Sys.info())
[17:28:18.518]                   }
[17:28:18.518]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.518]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.518]                     cond$call), session = sessionInformation(), 
[17:28:18.518]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.518]                   signalCondition(cond)
[17:28:18.518]                 }
[17:28:18.518]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.518]                 "immediateCondition"))) {
[17:28:18.518]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.518]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.518]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.518]                   if (TRUE && !signal) {
[17:28:18.518]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.518]                     {
[17:28:18.518]                       inherits <- base::inherits
[17:28:18.518]                       invokeRestart <- base::invokeRestart
[17:28:18.518]                       is.null <- base::is.null
[17:28:18.518]                       muffled <- FALSE
[17:28:18.518]                       if (inherits(cond, "message")) {
[17:28:18.518]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.518]                         if (muffled) 
[17:28:18.518]                           invokeRestart("muffleMessage")
[17:28:18.518]                       }
[17:28:18.518]                       else if (inherits(cond, "warning")) {
[17:28:18.518]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.518]                         if (muffled) 
[17:28:18.518]                           invokeRestart("muffleWarning")
[17:28:18.518]                       }
[17:28:18.518]                       else if (inherits(cond, "condition")) {
[17:28:18.518]                         if (!is.null(pattern)) {
[17:28:18.518]                           computeRestarts <- base::computeRestarts
[17:28:18.518]                           grepl <- base::grepl
[17:28:18.518]                           restarts <- computeRestarts(cond)
[17:28:18.518]                           for (restart in restarts) {
[17:28:18.518]                             name <- restart$name
[17:28:18.518]                             if (is.null(name)) 
[17:28:18.518]                               next
[17:28:18.518]                             if (!grepl(pattern, name)) 
[17:28:18.518]                               next
[17:28:18.518]                             invokeRestart(restart)
[17:28:18.518]                             muffled <- TRUE
[17:28:18.518]                             break
[17:28:18.518]                           }
[17:28:18.518]                         }
[17:28:18.518]                       }
[17:28:18.518]                       invisible(muffled)
[17:28:18.518]                     }
[17:28:18.518]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.518]                   }
[17:28:18.518]                 }
[17:28:18.518]                 else {
[17:28:18.518]                   if (TRUE) {
[17:28:18.518]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.518]                     {
[17:28:18.518]                       inherits <- base::inherits
[17:28:18.518]                       invokeRestart <- base::invokeRestart
[17:28:18.518]                       is.null <- base::is.null
[17:28:18.518]                       muffled <- FALSE
[17:28:18.518]                       if (inherits(cond, "message")) {
[17:28:18.518]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.518]                         if (muffled) 
[17:28:18.518]                           invokeRestart("muffleMessage")
[17:28:18.518]                       }
[17:28:18.518]                       else if (inherits(cond, "warning")) {
[17:28:18.518]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.518]                         if (muffled) 
[17:28:18.518]                           invokeRestart("muffleWarning")
[17:28:18.518]                       }
[17:28:18.518]                       else if (inherits(cond, "condition")) {
[17:28:18.518]                         if (!is.null(pattern)) {
[17:28:18.518]                           computeRestarts <- base::computeRestarts
[17:28:18.518]                           grepl <- base::grepl
[17:28:18.518]                           restarts <- computeRestarts(cond)
[17:28:18.518]                           for (restart in restarts) {
[17:28:18.518]                             name <- restart$name
[17:28:18.518]                             if (is.null(name)) 
[17:28:18.518]                               next
[17:28:18.518]                             if (!grepl(pattern, name)) 
[17:28:18.518]                               next
[17:28:18.518]                             invokeRestart(restart)
[17:28:18.518]                             muffled <- TRUE
[17:28:18.518]                             break
[17:28:18.518]                           }
[17:28:18.518]                         }
[17:28:18.518]                       }
[17:28:18.518]                       invisible(muffled)
[17:28:18.518]                     }
[17:28:18.518]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.518]                   }
[17:28:18.518]                 }
[17:28:18.518]             }
[17:28:18.518]         }))
[17:28:18.518]     }, error = function(ex) {
[17:28:18.518]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.518]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.518]                 ...future.rng), started = ...future.startTime, 
[17:28:18.518]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.518]             version = "1.8"), class = "FutureResult")
[17:28:18.518]     }, finally = {
[17:28:18.518]         if (!identical(...future.workdir, getwd())) 
[17:28:18.518]             setwd(...future.workdir)
[17:28:18.518]         {
[17:28:18.518]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.518]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.518]             }
[17:28:18.518]             base::options(...future.oldOptions)
[17:28:18.518]             if (.Platform$OS.type == "windows") {
[17:28:18.518]                 old_names <- names(...future.oldEnvVars)
[17:28:18.518]                 envs <- base::Sys.getenv()
[17:28:18.518]                 names <- names(envs)
[17:28:18.518]                 common <- intersect(names, old_names)
[17:28:18.518]                 added <- setdiff(names, old_names)
[17:28:18.518]                 removed <- setdiff(old_names, names)
[17:28:18.518]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.518]                   envs[common]]
[17:28:18.518]                 NAMES <- toupper(changed)
[17:28:18.518]                 args <- list()
[17:28:18.518]                 for (kk in seq_along(NAMES)) {
[17:28:18.518]                   name <- changed[[kk]]
[17:28:18.518]                   NAME <- NAMES[[kk]]
[17:28:18.518]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.518]                     next
[17:28:18.518]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.518]                 }
[17:28:18.518]                 NAMES <- toupper(added)
[17:28:18.518]                 for (kk in seq_along(NAMES)) {
[17:28:18.518]                   name <- added[[kk]]
[17:28:18.518]                   NAME <- NAMES[[kk]]
[17:28:18.518]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.518]                     next
[17:28:18.518]                   args[[name]] <- ""
[17:28:18.518]                 }
[17:28:18.518]                 NAMES <- toupper(removed)
[17:28:18.518]                 for (kk in seq_along(NAMES)) {
[17:28:18.518]                   name <- removed[[kk]]
[17:28:18.518]                   NAME <- NAMES[[kk]]
[17:28:18.518]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.518]                     next
[17:28:18.518]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.518]                 }
[17:28:18.518]                 if (length(args) > 0) 
[17:28:18.518]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.518]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.518]             }
[17:28:18.518]             else {
[17:28:18.518]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.518]             }
[17:28:18.518]             {
[17:28:18.518]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.518]                   0L) {
[17:28:18.518]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.518]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.518]                   base::options(opts)
[17:28:18.518]                 }
[17:28:18.518]                 {
[17:28:18.518]                   {
[17:28:18.518]                     base::assign(".Random.seed", c(10407L, -446836159L, 
[17:28:18.518]                     1518304212L, -1538054438L, -2128015266L, 
[17:28:18.518]                     1957638840L, 1211853682L), envir = base::globalenv(), 
[17:28:18.518]                       inherits = FALSE)
[17:28:18.518]                     NULL
[17:28:18.518]                   }
[17:28:18.518]                   options(future.plan = NULL)
[17:28:18.518]                   if (is.na(NA_character_)) 
[17:28:18.518]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.518]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.518]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.518]                     .init = FALSE)
[17:28:18.518]                 }
[17:28:18.518]             }
[17:28:18.518]         }
[17:28:18.518]     })
[17:28:18.518]     if (TRUE) {
[17:28:18.518]         base::sink(type = "output", split = FALSE)
[17:28:18.518]         if (TRUE) {
[17:28:18.518]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.518]         }
[17:28:18.518]         else {
[17:28:18.518]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.518]         }
[17:28:18.518]         base::close(...future.stdout)
[17:28:18.518]         ...future.stdout <- NULL
[17:28:18.518]     }
[17:28:18.518]     ...future.result$conditions <- ...future.conditions
[17:28:18.518]     ...future.result$finished <- base::Sys.time()
[17:28:18.518]     ...future.result
[17:28:18.518] }
[17:28:18.522] assign_globals() ...
[17:28:18.522] List of 1
[17:28:18.522]  $ x: int [1:4] 0 1 2 3
[17:28:18.522]  - attr(*, "where")=List of 1
[17:28:18.522]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.522]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.522]  - attr(*, "resolved")= logi FALSE
[17:28:18.522]  - attr(*, "total_size")= num 64
[17:28:18.522]  - attr(*, "already-done")= logi TRUE
[17:28:18.525] - copied 'x' to environment
[17:28:18.525] assign_globals() ... done
[17:28:18.526] plan(): Setting new future strategy stack:
[17:28:18.526] List of future strategies:
[17:28:18.526] 1. sequential:
[17:28:18.526]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.526]    - tweaked: FALSE
[17:28:18.526]    - call: NULL
[17:28:18.526] plan(): nbrOfWorkers() = 1
[17:28:18.528] plan(): Setting new future strategy stack:
[17:28:18.528] List of future strategies:
[17:28:18.528] 1. sequential:
[17:28:18.528]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.528]    - tweaked: FALSE
[17:28:18.528]    - call: plan(strategy)
[17:28:18.528] plan(): nbrOfWorkers() = 1
[17:28:18.529] SequentialFuture started (and completed)
[17:28:18.529] - Launch lazy future ... done
[17:28:18.529] run() for 'SequentialFuture' ... done
[17:28:18.529] getGlobalsAndPackages() ...
[17:28:18.530] Searching for globals...
[17:28:18.531] - globals found: [3] '{', 'sample', 'x'
[17:28:18.531] Searching for globals ... DONE
[17:28:18.531] Resolving globals: FALSE
[17:28:18.532] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.532] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.532] - globals: [1] 'x'
[17:28:18.532] 
[17:28:18.533] getGlobalsAndPackages() ... DONE
[17:28:18.533] run() for 'Future' ...
[17:28:18.533] - state: 'created'
[17:28:18.533] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.534] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.534] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.534]   - Field: 'label'
[17:28:18.534]   - Field: 'local'
[17:28:18.534]   - Field: 'owner'
[17:28:18.535]   - Field: 'envir'
[17:28:18.535]   - Field: 'packages'
[17:28:18.535]   - Field: 'gc'
[17:28:18.535]   - Field: 'conditions'
[17:28:18.535]   - Field: 'expr'
[17:28:18.535]   - Field: 'uuid'
[17:28:18.536]   - Field: 'seed'
[17:28:18.536]   - Field: 'version'
[17:28:18.536]   - Field: 'result'
[17:28:18.536]   - Field: 'asynchronous'
[17:28:18.536]   - Field: 'calls'
[17:28:18.536]   - Field: 'globals'
[17:28:18.537]   - Field: 'stdout'
[17:28:18.537]   - Field: 'earlySignal'
[17:28:18.537]   - Field: 'lazy'
[17:28:18.538]   - Field: 'state'
[17:28:18.538] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.538] - Launch lazy future ...
[17:28:18.539] Packages needed by the future expression (n = 0): <none>
[17:28:18.539] Packages needed by future strategies (n = 0): <none>
[17:28:18.539] {
[17:28:18.539]     {
[17:28:18.539]         {
[17:28:18.539]             ...future.startTime <- base::Sys.time()
[17:28:18.539]             {
[17:28:18.539]                 {
[17:28:18.539]                   {
[17:28:18.539]                     base::local({
[17:28:18.539]                       has_future <- base::requireNamespace("future", 
[17:28:18.539]                         quietly = TRUE)
[17:28:18.539]                       if (has_future) {
[17:28:18.539]                         ns <- base::getNamespace("future")
[17:28:18.539]                         version <- ns[[".package"]][["version"]]
[17:28:18.539]                         if (is.null(version)) 
[17:28:18.539]                           version <- utils::packageVersion("future")
[17:28:18.539]                       }
[17:28:18.539]                       else {
[17:28:18.539]                         version <- NULL
[17:28:18.539]                       }
[17:28:18.539]                       if (!has_future || version < "1.8.0") {
[17:28:18.539]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.539]                           "", base::R.version$version.string), 
[17:28:18.539]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.539]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.539]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.539]                             "release", "version")], collapse = " "), 
[17:28:18.539]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.539]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.539]                           info)
[17:28:18.539]                         info <- base::paste(info, collapse = "; ")
[17:28:18.539]                         if (!has_future) {
[17:28:18.539]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.539]                             info)
[17:28:18.539]                         }
[17:28:18.539]                         else {
[17:28:18.539]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.539]                             info, version)
[17:28:18.539]                         }
[17:28:18.539]                         base::stop(msg)
[17:28:18.539]                       }
[17:28:18.539]                     })
[17:28:18.539]                   }
[17:28:18.539]                   ...future.strategy.old <- future::plan("list")
[17:28:18.539]                   options(future.plan = NULL)
[17:28:18.539]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.539]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.539]                 }
[17:28:18.539]                 ...future.workdir <- getwd()
[17:28:18.539]             }
[17:28:18.539]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.539]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.539]         }
[17:28:18.539]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.539]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.539]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.539]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.539]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.539]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.539]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.539]             base::names(...future.oldOptions))
[17:28:18.539]     }
[17:28:18.539]     if (FALSE) {
[17:28:18.539]     }
[17:28:18.539]     else {
[17:28:18.539]         if (TRUE) {
[17:28:18.539]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.539]                 open = "w")
[17:28:18.539]         }
[17:28:18.539]         else {
[17:28:18.539]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.539]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.539]         }
[17:28:18.539]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.539]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.539]             base::sink(type = "output", split = FALSE)
[17:28:18.539]             base::close(...future.stdout)
[17:28:18.539]         }, add = TRUE)
[17:28:18.539]     }
[17:28:18.539]     ...future.frame <- base::sys.nframe()
[17:28:18.539]     ...future.conditions <- base::list()
[17:28:18.539]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.539]     if (FALSE) {
[17:28:18.539]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.539]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.539]     }
[17:28:18.539]     ...future.result <- base::tryCatch({
[17:28:18.539]         base::withCallingHandlers({
[17:28:18.539]             ...future.value <- base::withVisible(base::local({
[17:28:18.539]                 sample(x, size = 1L)
[17:28:18.539]             }))
[17:28:18.539]             future::FutureResult(value = ...future.value$value, 
[17:28:18.539]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.539]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.539]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.539]                     ...future.globalenv.names))
[17:28:18.539]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.539]         }, condition = base::local({
[17:28:18.539]             c <- base::c
[17:28:18.539]             inherits <- base::inherits
[17:28:18.539]             invokeRestart <- base::invokeRestart
[17:28:18.539]             length <- base::length
[17:28:18.539]             list <- base::list
[17:28:18.539]             seq.int <- base::seq.int
[17:28:18.539]             signalCondition <- base::signalCondition
[17:28:18.539]             sys.calls <- base::sys.calls
[17:28:18.539]             `[[` <- base::`[[`
[17:28:18.539]             `+` <- base::`+`
[17:28:18.539]             `<<-` <- base::`<<-`
[17:28:18.539]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.539]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.539]                   3L)]
[17:28:18.539]             }
[17:28:18.539]             function(cond) {
[17:28:18.539]                 is_error <- inherits(cond, "error")
[17:28:18.539]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.539]                   NULL)
[17:28:18.539]                 if (is_error) {
[17:28:18.539]                   sessionInformation <- function() {
[17:28:18.539]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.539]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.539]                       search = base::search(), system = base::Sys.info())
[17:28:18.539]                   }
[17:28:18.539]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.539]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.539]                     cond$call), session = sessionInformation(), 
[17:28:18.539]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.539]                   signalCondition(cond)
[17:28:18.539]                 }
[17:28:18.539]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.539]                 "immediateCondition"))) {
[17:28:18.539]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.539]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.539]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.539]                   if (TRUE && !signal) {
[17:28:18.539]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.539]                     {
[17:28:18.539]                       inherits <- base::inherits
[17:28:18.539]                       invokeRestart <- base::invokeRestart
[17:28:18.539]                       is.null <- base::is.null
[17:28:18.539]                       muffled <- FALSE
[17:28:18.539]                       if (inherits(cond, "message")) {
[17:28:18.539]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.539]                         if (muffled) 
[17:28:18.539]                           invokeRestart("muffleMessage")
[17:28:18.539]                       }
[17:28:18.539]                       else if (inherits(cond, "warning")) {
[17:28:18.539]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.539]                         if (muffled) 
[17:28:18.539]                           invokeRestart("muffleWarning")
[17:28:18.539]                       }
[17:28:18.539]                       else if (inherits(cond, "condition")) {
[17:28:18.539]                         if (!is.null(pattern)) {
[17:28:18.539]                           computeRestarts <- base::computeRestarts
[17:28:18.539]                           grepl <- base::grepl
[17:28:18.539]                           restarts <- computeRestarts(cond)
[17:28:18.539]                           for (restart in restarts) {
[17:28:18.539]                             name <- restart$name
[17:28:18.539]                             if (is.null(name)) 
[17:28:18.539]                               next
[17:28:18.539]                             if (!grepl(pattern, name)) 
[17:28:18.539]                               next
[17:28:18.539]                             invokeRestart(restart)
[17:28:18.539]                             muffled <- TRUE
[17:28:18.539]                             break
[17:28:18.539]                           }
[17:28:18.539]                         }
[17:28:18.539]                       }
[17:28:18.539]                       invisible(muffled)
[17:28:18.539]                     }
[17:28:18.539]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.539]                   }
[17:28:18.539]                 }
[17:28:18.539]                 else {
[17:28:18.539]                   if (TRUE) {
[17:28:18.539]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.539]                     {
[17:28:18.539]                       inherits <- base::inherits
[17:28:18.539]                       invokeRestart <- base::invokeRestart
[17:28:18.539]                       is.null <- base::is.null
[17:28:18.539]                       muffled <- FALSE
[17:28:18.539]                       if (inherits(cond, "message")) {
[17:28:18.539]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.539]                         if (muffled) 
[17:28:18.539]                           invokeRestart("muffleMessage")
[17:28:18.539]                       }
[17:28:18.539]                       else if (inherits(cond, "warning")) {
[17:28:18.539]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.539]                         if (muffled) 
[17:28:18.539]                           invokeRestart("muffleWarning")
[17:28:18.539]                       }
[17:28:18.539]                       else if (inherits(cond, "condition")) {
[17:28:18.539]                         if (!is.null(pattern)) {
[17:28:18.539]                           computeRestarts <- base::computeRestarts
[17:28:18.539]                           grepl <- base::grepl
[17:28:18.539]                           restarts <- computeRestarts(cond)
[17:28:18.539]                           for (restart in restarts) {
[17:28:18.539]                             name <- restart$name
[17:28:18.539]                             if (is.null(name)) 
[17:28:18.539]                               next
[17:28:18.539]                             if (!grepl(pattern, name)) 
[17:28:18.539]                               next
[17:28:18.539]                             invokeRestart(restart)
[17:28:18.539]                             muffled <- TRUE
[17:28:18.539]                             break
[17:28:18.539]                           }
[17:28:18.539]                         }
[17:28:18.539]                       }
[17:28:18.539]                       invisible(muffled)
[17:28:18.539]                     }
[17:28:18.539]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.539]                   }
[17:28:18.539]                 }
[17:28:18.539]             }
[17:28:18.539]         }))
[17:28:18.539]     }, error = function(ex) {
[17:28:18.539]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.539]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.539]                 ...future.rng), started = ...future.startTime, 
[17:28:18.539]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.539]             version = "1.8"), class = "FutureResult")
[17:28:18.539]     }, finally = {
[17:28:18.539]         if (!identical(...future.workdir, getwd())) 
[17:28:18.539]             setwd(...future.workdir)
[17:28:18.539]         {
[17:28:18.539]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.539]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.539]             }
[17:28:18.539]             base::options(...future.oldOptions)
[17:28:18.539]             if (.Platform$OS.type == "windows") {
[17:28:18.539]                 old_names <- names(...future.oldEnvVars)
[17:28:18.539]                 envs <- base::Sys.getenv()
[17:28:18.539]                 names <- names(envs)
[17:28:18.539]                 common <- intersect(names, old_names)
[17:28:18.539]                 added <- setdiff(names, old_names)
[17:28:18.539]                 removed <- setdiff(old_names, names)
[17:28:18.539]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.539]                   envs[common]]
[17:28:18.539]                 NAMES <- toupper(changed)
[17:28:18.539]                 args <- list()
[17:28:18.539]                 for (kk in seq_along(NAMES)) {
[17:28:18.539]                   name <- changed[[kk]]
[17:28:18.539]                   NAME <- NAMES[[kk]]
[17:28:18.539]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.539]                     next
[17:28:18.539]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.539]                 }
[17:28:18.539]                 NAMES <- toupper(added)
[17:28:18.539]                 for (kk in seq_along(NAMES)) {
[17:28:18.539]                   name <- added[[kk]]
[17:28:18.539]                   NAME <- NAMES[[kk]]
[17:28:18.539]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.539]                     next
[17:28:18.539]                   args[[name]] <- ""
[17:28:18.539]                 }
[17:28:18.539]                 NAMES <- toupper(removed)
[17:28:18.539]                 for (kk in seq_along(NAMES)) {
[17:28:18.539]                   name <- removed[[kk]]
[17:28:18.539]                   NAME <- NAMES[[kk]]
[17:28:18.539]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.539]                     next
[17:28:18.539]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.539]                 }
[17:28:18.539]                 if (length(args) > 0) 
[17:28:18.539]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.539]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.539]             }
[17:28:18.539]             else {
[17:28:18.539]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.539]             }
[17:28:18.539]             {
[17:28:18.539]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.539]                   0L) {
[17:28:18.539]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.539]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.539]                   base::options(opts)
[17:28:18.539]                 }
[17:28:18.539]                 {
[17:28:18.539]                   {
[17:28:18.539]                     base::assign(".Random.seed", c(10407L, -1538054438L, 
[17:28:18.539]                     958671146L, -1312820442L, 1211853682L, 876515677L, 
[17:28:18.539]                     4105284L), envir = base::globalenv(), inherits = FALSE)
[17:28:18.539]                     NULL
[17:28:18.539]                   }
[17:28:18.539]                   options(future.plan = NULL)
[17:28:18.539]                   if (is.na(NA_character_)) 
[17:28:18.539]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.539]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.539]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.539]                     .init = FALSE)
[17:28:18.539]                 }
[17:28:18.539]             }
[17:28:18.539]         }
[17:28:18.539]     })
[17:28:18.539]     if (TRUE) {
[17:28:18.539]         base::sink(type = "output", split = FALSE)
[17:28:18.539]         if (TRUE) {
[17:28:18.539]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.539]         }
[17:28:18.539]         else {
[17:28:18.539]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.539]         }
[17:28:18.539]         base::close(...future.stdout)
[17:28:18.539]         ...future.stdout <- NULL
[17:28:18.539]     }
[17:28:18.539]     ...future.result$conditions <- ...future.conditions
[17:28:18.539]     ...future.result$finished <- base::Sys.time()
[17:28:18.539]     ...future.result
[17:28:18.539] }
[17:28:18.543] assign_globals() ...
[17:28:18.543] List of 1
[17:28:18.543]  $ x: int [1:4] 0 1 2 3
[17:28:18.543]  - attr(*, "where")=List of 1
[17:28:18.543]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.543]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.543]  - attr(*, "resolved")= logi FALSE
[17:28:18.543]  - attr(*, "total_size")= num 64
[17:28:18.543]  - attr(*, "already-done")= logi TRUE
[17:28:18.546] - copied 'x' to environment
[17:28:18.547] assign_globals() ... done
[17:28:18.547] plan(): Setting new future strategy stack:
[17:28:18.547] List of future strategies:
[17:28:18.547] 1. sequential:
[17:28:18.547]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.547]    - tweaked: FALSE
[17:28:18.547]    - call: NULL
[17:28:18.548] plan(): nbrOfWorkers() = 1
[17:28:18.549] plan(): Setting new future strategy stack:
[17:28:18.549] List of future strategies:
[17:28:18.549] 1. sequential:
[17:28:18.549]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.549]    - tweaked: FALSE
[17:28:18.549]    - call: plan(strategy)
[17:28:18.550] plan(): nbrOfWorkers() = 1
[17:28:18.550] SequentialFuture started (and completed)
[17:28:18.550] - Launch lazy future ... done
[17:28:18.550] run() for 'SequentialFuture' ... done
[17:28:18.551] Future state: 'finished'
[17:28:18.551] signalConditions() ...
[17:28:18.551]  - include = 'condition'
[17:28:18.551]  - exclude = 'immediateCondition'
[17:28:18.551]  - resignal = TRUE
[17:28:18.552]  - Number of conditions: 1
[17:28:18.552]  - Condition #1: 'RngFutureError', 'FutureError', 'error', 'RngFutureCondition', 'FutureCondition', 'condition'
[17:28:18.552] signalConditions() ... done
<RngFutureError: UNRELIABLE VALUE: Future ('fsample_1-316434') 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: f50daa1c-9f3f-75fc-7b38-af0f9806c660


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

DEBUG: END TROUBLESHOOTING HELP
[17:28:18.553] getGlobalsAndPackages() ...
[17:28:18.554] Searching for globals...
[17:28:18.555] - globals found: [3] '{', 'sample', 'x'
[17:28:18.555] Searching for globals ... DONE
[17:28:18.555] Resolving globals: FALSE
[17:28:18.555] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.556] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.556] - globals: [1] 'x'
[17:28:18.556] 
[17:28:18.556] getGlobalsAndPackages() ... DONE
[17:28:18.557] run() for 'Future' ...
[17:28:18.557] - state: 'created'
[17:28:18.557] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.557] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.558] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.558]   - Field: 'label'
[17:28:18.558]   - Field: 'local'
[17:28:18.558]   - Field: 'owner'
[17:28:18.558]   - Field: 'envir'
[17:28:18.559]   - Field: 'packages'
[17:28:18.559]   - Field: 'gc'
[17:28:18.559]   - Field: 'conditions'
[17:28:18.559]   - Field: 'expr'
[17:28:18.559]   - Field: 'uuid'
[17:28:18.559]   - Field: 'seed'
[17:28:18.560]   - Field: 'version'
[17:28:18.560]   - Field: 'result'
[17:28:18.560]   - Field: 'asynchronous'
[17:28:18.560]   - Field: 'calls'
[17:28:18.560]   - Field: 'globals'
[17:28:18.560]   - Field: 'stdout'
[17:28:18.561]   - Field: 'earlySignal'
[17:28:18.561]   - Field: 'lazy'
[17:28:18.561]   - Field: 'state'
[17:28:18.561] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.561] - Launch lazy future ...
[17:28:18.562] Packages needed by the future expression (n = 0): <none>
[17:28:18.562] Packages needed by future strategies (n = 0): <none>
[17:28:18.562] {
[17:28:18.562]     {
[17:28:18.562]         {
[17:28:18.562]             ...future.startTime <- base::Sys.time()
[17:28:18.562]             {
[17:28:18.562]                 {
[17:28:18.562]                   {
[17:28:18.562]                     base::local({
[17:28:18.562]                       has_future <- base::requireNamespace("future", 
[17:28:18.562]                         quietly = TRUE)
[17:28:18.562]                       if (has_future) {
[17:28:18.562]                         ns <- base::getNamespace("future")
[17:28:18.562]                         version <- ns[[".package"]][["version"]]
[17:28:18.562]                         if (is.null(version)) 
[17:28:18.562]                           version <- utils::packageVersion("future")
[17:28:18.562]                       }
[17:28:18.562]                       else {
[17:28:18.562]                         version <- NULL
[17:28:18.562]                       }
[17:28:18.562]                       if (!has_future || version < "1.8.0") {
[17:28:18.562]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.562]                           "", base::R.version$version.string), 
[17:28:18.562]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.562]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.562]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.562]                             "release", "version")], collapse = " "), 
[17:28:18.562]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.562]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.562]                           info)
[17:28:18.562]                         info <- base::paste(info, collapse = "; ")
[17:28:18.562]                         if (!has_future) {
[17:28:18.562]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.562]                             info)
[17:28:18.562]                         }
[17:28:18.562]                         else {
[17:28:18.562]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.562]                             info, version)
[17:28:18.562]                         }
[17:28:18.562]                         base::stop(msg)
[17:28:18.562]                       }
[17:28:18.562]                     })
[17:28:18.562]                   }
[17:28:18.562]                   ...future.strategy.old <- future::plan("list")
[17:28:18.562]                   options(future.plan = NULL)
[17:28:18.562]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.562]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.562]                 }
[17:28:18.562]                 ...future.workdir <- getwd()
[17:28:18.562]             }
[17:28:18.562]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.562]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.562]         }
[17:28:18.562]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.562]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.562]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.562]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.562]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.562]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.562]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.562]             base::names(...future.oldOptions))
[17:28:18.562]     }
[17:28:18.562]     if (FALSE) {
[17:28:18.562]     }
[17:28:18.562]     else {
[17:28:18.562]         if (TRUE) {
[17:28:18.562]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.562]                 open = "w")
[17:28:18.562]         }
[17:28:18.562]         else {
[17:28:18.562]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.562]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.562]         }
[17:28:18.562]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.562]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.562]             base::sink(type = "output", split = FALSE)
[17:28:18.562]             base::close(...future.stdout)
[17:28:18.562]         }, add = TRUE)
[17:28:18.562]     }
[17:28:18.562]     ...future.frame <- base::sys.nframe()
[17:28:18.562]     ...future.conditions <- base::list()
[17:28:18.562]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.562]     if (FALSE) {
[17:28:18.562]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.562]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.562]     }
[17:28:18.562]     ...future.result <- base::tryCatch({
[17:28:18.562]         base::withCallingHandlers({
[17:28:18.562]             ...future.value <- base::withVisible(base::local({
[17:28:18.562]                 sample(x, size = 1L)
[17:28:18.562]             }))
[17:28:18.562]             future::FutureResult(value = ...future.value$value, 
[17:28:18.562]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.562]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.562]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.562]                     ...future.globalenv.names))
[17:28:18.562]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.562]         }, condition = base::local({
[17:28:18.562]             c <- base::c
[17:28:18.562]             inherits <- base::inherits
[17:28:18.562]             invokeRestart <- base::invokeRestart
[17:28:18.562]             length <- base::length
[17:28:18.562]             list <- base::list
[17:28:18.562]             seq.int <- base::seq.int
[17:28:18.562]             signalCondition <- base::signalCondition
[17:28:18.562]             sys.calls <- base::sys.calls
[17:28:18.562]             `[[` <- base::`[[`
[17:28:18.562]             `+` <- base::`+`
[17:28:18.562]             `<<-` <- base::`<<-`
[17:28:18.562]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.562]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.562]                   3L)]
[17:28:18.562]             }
[17:28:18.562]             function(cond) {
[17:28:18.562]                 is_error <- inherits(cond, "error")
[17:28:18.562]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.562]                   NULL)
[17:28:18.562]                 if (is_error) {
[17:28:18.562]                   sessionInformation <- function() {
[17:28:18.562]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.562]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.562]                       search = base::search(), system = base::Sys.info())
[17:28:18.562]                   }
[17:28:18.562]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.562]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.562]                     cond$call), session = sessionInformation(), 
[17:28:18.562]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.562]                   signalCondition(cond)
[17:28:18.562]                 }
[17:28:18.562]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.562]                 "immediateCondition"))) {
[17:28:18.562]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.562]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.562]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.562]                   if (TRUE && !signal) {
[17:28:18.562]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.562]                     {
[17:28:18.562]                       inherits <- base::inherits
[17:28:18.562]                       invokeRestart <- base::invokeRestart
[17:28:18.562]                       is.null <- base::is.null
[17:28:18.562]                       muffled <- FALSE
[17:28:18.562]                       if (inherits(cond, "message")) {
[17:28:18.562]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.562]                         if (muffled) 
[17:28:18.562]                           invokeRestart("muffleMessage")
[17:28:18.562]                       }
[17:28:18.562]                       else if (inherits(cond, "warning")) {
[17:28:18.562]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.562]                         if (muffled) 
[17:28:18.562]                           invokeRestart("muffleWarning")
[17:28:18.562]                       }
[17:28:18.562]                       else if (inherits(cond, "condition")) {
[17:28:18.562]                         if (!is.null(pattern)) {
[17:28:18.562]                           computeRestarts <- base::computeRestarts
[17:28:18.562]                           grepl <- base::grepl
[17:28:18.562]                           restarts <- computeRestarts(cond)
[17:28:18.562]                           for (restart in restarts) {
[17:28:18.562]                             name <- restart$name
[17:28:18.562]                             if (is.null(name)) 
[17:28:18.562]                               next
[17:28:18.562]                             if (!grepl(pattern, name)) 
[17:28:18.562]                               next
[17:28:18.562]                             invokeRestart(restart)
[17:28:18.562]                             muffled <- TRUE
[17:28:18.562]                             break
[17:28:18.562]                           }
[17:28:18.562]                         }
[17:28:18.562]                       }
[17:28:18.562]                       invisible(muffled)
[17:28:18.562]                     }
[17:28:18.562]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.562]                   }
[17:28:18.562]                 }
[17:28:18.562]                 else {
[17:28:18.562]                   if (TRUE) {
[17:28:18.562]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.562]                     {
[17:28:18.562]                       inherits <- base::inherits
[17:28:18.562]                       invokeRestart <- base::invokeRestart
[17:28:18.562]                       is.null <- base::is.null
[17:28:18.562]                       muffled <- FALSE
[17:28:18.562]                       if (inherits(cond, "message")) {
[17:28:18.562]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.562]                         if (muffled) 
[17:28:18.562]                           invokeRestart("muffleMessage")
[17:28:18.562]                       }
[17:28:18.562]                       else if (inherits(cond, "warning")) {
[17:28:18.562]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.562]                         if (muffled) 
[17:28:18.562]                           invokeRestart("muffleWarning")
[17:28:18.562]                       }
[17:28:18.562]                       else if (inherits(cond, "condition")) {
[17:28:18.562]                         if (!is.null(pattern)) {
[17:28:18.562]                           computeRestarts <- base::computeRestarts
[17:28:18.562]                           grepl <- base::grepl
[17:28:18.562]                           restarts <- computeRestarts(cond)
[17:28:18.562]                           for (restart in restarts) {
[17:28:18.562]                             name <- restart$name
[17:28:18.562]                             if (is.null(name)) 
[17:28:18.562]                               next
[17:28:18.562]                             if (!grepl(pattern, name)) 
[17:28:18.562]                               next
[17:28:18.562]                             invokeRestart(restart)
[17:28:18.562]                             muffled <- TRUE
[17:28:18.562]                             break
[17:28:18.562]                           }
[17:28:18.562]                         }
[17:28:18.562]                       }
[17:28:18.562]                       invisible(muffled)
[17:28:18.562]                     }
[17:28:18.562]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.562]                   }
[17:28:18.562]                 }
[17:28:18.562]             }
[17:28:18.562]         }))
[17:28:18.562]     }, error = function(ex) {
[17:28:18.562]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.562]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.562]                 ...future.rng), started = ...future.startTime, 
[17:28:18.562]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.562]             version = "1.8"), class = "FutureResult")
[17:28:18.562]     }, finally = {
[17:28:18.562]         if (!identical(...future.workdir, getwd())) 
[17:28:18.562]             setwd(...future.workdir)
[17:28:18.562]         {
[17:28:18.562]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.562]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.562]             }
[17:28:18.562]             base::options(...future.oldOptions)
[17:28:18.562]             if (.Platform$OS.type == "windows") {
[17:28:18.562]                 old_names <- names(...future.oldEnvVars)
[17:28:18.562]                 envs <- base::Sys.getenv()
[17:28:18.562]                 names <- names(envs)
[17:28:18.562]                 common <- intersect(names, old_names)
[17:28:18.562]                 added <- setdiff(names, old_names)
[17:28:18.562]                 removed <- setdiff(old_names, names)
[17:28:18.562]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.562]                   envs[common]]
[17:28:18.562]                 NAMES <- toupper(changed)
[17:28:18.562]                 args <- list()
[17:28:18.562]                 for (kk in seq_along(NAMES)) {
[17:28:18.562]                   name <- changed[[kk]]
[17:28:18.562]                   NAME <- NAMES[[kk]]
[17:28:18.562]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.562]                     next
[17:28:18.562]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.562]                 }
[17:28:18.562]                 NAMES <- toupper(added)
[17:28:18.562]                 for (kk in seq_along(NAMES)) {
[17:28:18.562]                   name <- added[[kk]]
[17:28:18.562]                   NAME <- NAMES[[kk]]
[17:28:18.562]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.562]                     next
[17:28:18.562]                   args[[name]] <- ""
[17:28:18.562]                 }
[17:28:18.562]                 NAMES <- toupper(removed)
[17:28:18.562]                 for (kk in seq_along(NAMES)) {
[17:28:18.562]                   name <- removed[[kk]]
[17:28:18.562]                   NAME <- NAMES[[kk]]
[17:28:18.562]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.562]                     next
[17:28:18.562]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.562]                 }
[17:28:18.562]                 if (length(args) > 0) 
[17:28:18.562]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.562]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.562]             }
[17:28:18.562]             else {
[17:28:18.562]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.562]             }
[17:28:18.562]             {
[17:28:18.562]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.562]                   0L) {
[17:28:18.562]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.562]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.562]                   base::options(opts)
[17:28:18.562]                 }
[17:28:18.562]                 {
[17:28:18.562]                   {
[17:28:18.562]                     base::assign(".Random.seed", c(10407L, -1068574288L, 
[17:28:18.562]                     -1056568618L, 817755046L, 914010983L, 859132510L, 
[17:28:18.562]                     -1013881922L), envir = base::globalenv(), 
[17:28:18.562]                       inherits = FALSE)
[17:28:18.562]                     NULL
[17:28:18.562]                   }
[17:28:18.562]                   options(future.plan = NULL)
[17:28:18.562]                   if (is.na(NA_character_)) 
[17:28:18.562]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.562]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.562]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.562]                     .init = FALSE)
[17:28:18.562]                 }
[17:28:18.562]             }
[17:28:18.562]         }
[17:28:18.562]     })
[17:28:18.562]     if (TRUE) {
[17:28:18.562]         base::sink(type = "output", split = FALSE)
[17:28:18.562]         if (TRUE) {
[17:28:18.562]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.562]         }
[17:28:18.562]         else {
[17:28:18.562]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.562]         }
[17:28:18.562]         base::close(...future.stdout)
[17:28:18.562]         ...future.stdout <- NULL
[17:28:18.562]     }
[17:28:18.562]     ...future.result$conditions <- ...future.conditions
[17:28:18.562]     ...future.result$finished <- base::Sys.time()
[17:28:18.562]     ...future.result
[17:28:18.562] }
[17:28:18.566] assign_globals() ...
[17:28:18.566] List of 1
[17:28:18.566]  $ x: int [1:4] 0 1 2 3
[17:28:18.566]  - attr(*, "where")=List of 1
[17:28:18.566]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.566]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.566]  - attr(*, "resolved")= logi FALSE
[17:28:18.566]  - attr(*, "total_size")= num 64
[17:28:18.566]  - attr(*, "already-done")= logi TRUE
[17:28:18.570] - copied 'x' to environment
[17:28:18.570] assign_globals() ... done
[17:28:18.571] plan(): Setting new future strategy stack:
[17:28:18.571] List of future strategies:
[17:28:18.571] 1. sequential:
[17:28:18.571]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.571]    - tweaked: FALSE
[17:28:18.571]    - call: NULL
[17:28:18.571] plan(): nbrOfWorkers() = 1
[17:28:18.573] plan(): Setting new future strategy stack:
[17:28:18.573] List of future strategies:
[17:28:18.573] 1. sequential:
[17:28:18.573]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.573]    - tweaked: FALSE
[17:28:18.573]    - call: plan(strategy)
[17:28:18.573] plan(): nbrOfWorkers() = 1
[17:28:18.574] SequentialFuture started (and completed)
[17:28:18.574] - Launch lazy future ... done
[17:28:18.574] run() for 'SequentialFuture' ... done
[17:28:18.575] getGlobalsAndPackages() ...
[17:28:18.575] Searching for globals...
[17:28:18.576] - globals found: [3] '{', 'sample', 'x'
[17:28:18.576] Searching for globals ... DONE
[17:28:18.576] Resolving globals: FALSE
[17:28:18.577] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.577] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.577] - globals: [1] 'x'
[17:28:18.578] 
[17:28:18.578] getGlobalsAndPackages() ... DONE
[17:28:18.578] run() for 'Future' ...
[17:28:18.578] - state: 'created'
[17:28:18.578] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.579] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.579] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.579]   - Field: 'label'
[17:28:18.579]   - Field: 'local'
[17:28:18.579]   - Field: 'owner'
[17:28:18.580]   - Field: 'envir'
[17:28:18.580]   - Field: 'packages'
[17:28:18.580]   - Field: 'gc'
[17:28:18.580]   - Field: 'conditions'
[17:28:18.580]   - Field: 'expr'
[17:28:18.580]   - Field: 'uuid'
[17:28:18.581]   - Field: 'seed'
[17:28:18.581]   - Field: 'version'
[17:28:18.581]   - Field: 'result'
[17:28:18.581]   - Field: 'asynchronous'
[17:28:18.581]   - Field: 'calls'
[17:28:18.582]   - Field: 'globals'
[17:28:18.582]   - Field: 'stdout'
[17:28:18.582]   - Field: 'earlySignal'
[17:28:18.582]   - Field: 'lazy'
[17:28:18.582]   - Field: 'state'
[17:28:18.582] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.583] - Launch lazy future ...
[17:28:18.583] Packages needed by the future expression (n = 0): <none>
[17:28:18.583] Packages needed by future strategies (n = 0): <none>
[17:28:18.583] {
[17:28:18.583]     {
[17:28:18.583]         {
[17:28:18.583]             ...future.startTime <- base::Sys.time()
[17:28:18.583]             {
[17:28:18.583]                 {
[17:28:18.583]                   {
[17:28:18.583]                     base::local({
[17:28:18.583]                       has_future <- base::requireNamespace("future", 
[17:28:18.583]                         quietly = TRUE)
[17:28:18.583]                       if (has_future) {
[17:28:18.583]                         ns <- base::getNamespace("future")
[17:28:18.583]                         version <- ns[[".package"]][["version"]]
[17:28:18.583]                         if (is.null(version)) 
[17:28:18.583]                           version <- utils::packageVersion("future")
[17:28:18.583]                       }
[17:28:18.583]                       else {
[17:28:18.583]                         version <- NULL
[17:28:18.583]                       }
[17:28:18.583]                       if (!has_future || version < "1.8.0") {
[17:28:18.583]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.583]                           "", base::R.version$version.string), 
[17:28:18.583]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.583]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.583]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.583]                             "release", "version")], collapse = " "), 
[17:28:18.583]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.583]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.583]                           info)
[17:28:18.583]                         info <- base::paste(info, collapse = "; ")
[17:28:18.583]                         if (!has_future) {
[17:28:18.583]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.583]                             info)
[17:28:18.583]                         }
[17:28:18.583]                         else {
[17:28:18.583]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.583]                             info, version)
[17:28:18.583]                         }
[17:28:18.583]                         base::stop(msg)
[17:28:18.583]                       }
[17:28:18.583]                     })
[17:28:18.583]                   }
[17:28:18.583]                   ...future.strategy.old <- future::plan("list")
[17:28:18.583]                   options(future.plan = NULL)
[17:28:18.583]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.583]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.583]                 }
[17:28:18.583]                 ...future.workdir <- getwd()
[17:28:18.583]             }
[17:28:18.583]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.583]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.583]         }
[17:28:18.583]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.583]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.583]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.583]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.583]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.583]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.583]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.583]             base::names(...future.oldOptions))
[17:28:18.583]     }
[17:28:18.583]     if (FALSE) {
[17:28:18.583]     }
[17:28:18.583]     else {
[17:28:18.583]         if (TRUE) {
[17:28:18.583]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.583]                 open = "w")
[17:28:18.583]         }
[17:28:18.583]         else {
[17:28:18.583]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.583]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.583]         }
[17:28:18.583]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.583]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.583]             base::sink(type = "output", split = FALSE)
[17:28:18.583]             base::close(...future.stdout)
[17:28:18.583]         }, add = TRUE)
[17:28:18.583]     }
[17:28:18.583]     ...future.frame <- base::sys.nframe()
[17:28:18.583]     ...future.conditions <- base::list()
[17:28:18.583]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.583]     if (FALSE) {
[17:28:18.583]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.583]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.583]     }
[17:28:18.583]     ...future.result <- base::tryCatch({
[17:28:18.583]         base::withCallingHandlers({
[17:28:18.583]             ...future.value <- base::withVisible(base::local({
[17:28:18.583]                 sample(x, size = 1L)
[17:28:18.583]             }))
[17:28:18.583]             future::FutureResult(value = ...future.value$value, 
[17:28:18.583]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.583]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.583]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.583]                     ...future.globalenv.names))
[17:28:18.583]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.583]         }, condition = base::local({
[17:28:18.583]             c <- base::c
[17:28:18.583]             inherits <- base::inherits
[17:28:18.583]             invokeRestart <- base::invokeRestart
[17:28:18.583]             length <- base::length
[17:28:18.583]             list <- base::list
[17:28:18.583]             seq.int <- base::seq.int
[17:28:18.583]             signalCondition <- base::signalCondition
[17:28:18.583]             sys.calls <- base::sys.calls
[17:28:18.583]             `[[` <- base::`[[`
[17:28:18.583]             `+` <- base::`+`
[17:28:18.583]             `<<-` <- base::`<<-`
[17:28:18.583]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.583]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.583]                   3L)]
[17:28:18.583]             }
[17:28:18.583]             function(cond) {
[17:28:18.583]                 is_error <- inherits(cond, "error")
[17:28:18.583]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.583]                   NULL)
[17:28:18.583]                 if (is_error) {
[17:28:18.583]                   sessionInformation <- function() {
[17:28:18.583]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.583]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.583]                       search = base::search(), system = base::Sys.info())
[17:28:18.583]                   }
[17:28:18.583]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.583]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.583]                     cond$call), session = sessionInformation(), 
[17:28:18.583]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.583]                   signalCondition(cond)
[17:28:18.583]                 }
[17:28:18.583]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.583]                 "immediateCondition"))) {
[17:28:18.583]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.583]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.583]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.583]                   if (TRUE && !signal) {
[17:28:18.583]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.583]                     {
[17:28:18.583]                       inherits <- base::inherits
[17:28:18.583]                       invokeRestart <- base::invokeRestart
[17:28:18.583]                       is.null <- base::is.null
[17:28:18.583]                       muffled <- FALSE
[17:28:18.583]                       if (inherits(cond, "message")) {
[17:28:18.583]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.583]                         if (muffled) 
[17:28:18.583]                           invokeRestart("muffleMessage")
[17:28:18.583]                       }
[17:28:18.583]                       else if (inherits(cond, "warning")) {
[17:28:18.583]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.583]                         if (muffled) 
[17:28:18.583]                           invokeRestart("muffleWarning")
[17:28:18.583]                       }
[17:28:18.583]                       else if (inherits(cond, "condition")) {
[17:28:18.583]                         if (!is.null(pattern)) {
[17:28:18.583]                           computeRestarts <- base::computeRestarts
[17:28:18.583]                           grepl <- base::grepl
[17:28:18.583]                           restarts <- computeRestarts(cond)
[17:28:18.583]                           for (restart in restarts) {
[17:28:18.583]                             name <- restart$name
[17:28:18.583]                             if (is.null(name)) 
[17:28:18.583]                               next
[17:28:18.583]                             if (!grepl(pattern, name)) 
[17:28:18.583]                               next
[17:28:18.583]                             invokeRestart(restart)
[17:28:18.583]                             muffled <- TRUE
[17:28:18.583]                             break
[17:28:18.583]                           }
[17:28:18.583]                         }
[17:28:18.583]                       }
[17:28:18.583]                       invisible(muffled)
[17:28:18.583]                     }
[17:28:18.583]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.583]                   }
[17:28:18.583]                 }
[17:28:18.583]                 else {
[17:28:18.583]                   if (TRUE) {
[17:28:18.583]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.583]                     {
[17:28:18.583]                       inherits <- base::inherits
[17:28:18.583]                       invokeRestart <- base::invokeRestart
[17:28:18.583]                       is.null <- base::is.null
[17:28:18.583]                       muffled <- FALSE
[17:28:18.583]                       if (inherits(cond, "message")) {
[17:28:18.583]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.583]                         if (muffled) 
[17:28:18.583]                           invokeRestart("muffleMessage")
[17:28:18.583]                       }
[17:28:18.583]                       else if (inherits(cond, "warning")) {
[17:28:18.583]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.583]                         if (muffled) 
[17:28:18.583]                           invokeRestart("muffleWarning")
[17:28:18.583]                       }
[17:28:18.583]                       else if (inherits(cond, "condition")) {
[17:28:18.583]                         if (!is.null(pattern)) {
[17:28:18.583]                           computeRestarts <- base::computeRestarts
[17:28:18.583]                           grepl <- base::grepl
[17:28:18.583]                           restarts <- computeRestarts(cond)
[17:28:18.583]                           for (restart in restarts) {
[17:28:18.583]                             name <- restart$name
[17:28:18.583]                             if (is.null(name)) 
[17:28:18.583]                               next
[17:28:18.583]                             if (!grepl(pattern, name)) 
[17:28:18.583]                               next
[17:28:18.583]                             invokeRestart(restart)
[17:28:18.583]                             muffled <- TRUE
[17:28:18.583]                             break
[17:28:18.583]                           }
[17:28:18.583]                         }
[17:28:18.583]                       }
[17:28:18.583]                       invisible(muffled)
[17:28:18.583]                     }
[17:28:18.583]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.583]                   }
[17:28:18.583]                 }
[17:28:18.583]             }
[17:28:18.583]         }))
[17:28:18.583]     }, error = function(ex) {
[17:28:18.583]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.583]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.583]                 ...future.rng), started = ...future.startTime, 
[17:28:18.583]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.583]             version = "1.8"), class = "FutureResult")
[17:28:18.583]     }, finally = {
[17:28:18.583]         if (!identical(...future.workdir, getwd())) 
[17:28:18.583]             setwd(...future.workdir)
[17:28:18.583]         {
[17:28:18.583]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.583]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.583]             }
[17:28:18.583]             base::options(...future.oldOptions)
[17:28:18.583]             if (.Platform$OS.type == "windows") {
[17:28:18.583]                 old_names <- names(...future.oldEnvVars)
[17:28:18.583]                 envs <- base::Sys.getenv()
[17:28:18.583]                 names <- names(envs)
[17:28:18.583]                 common <- intersect(names, old_names)
[17:28:18.583]                 added <- setdiff(names, old_names)
[17:28:18.583]                 removed <- setdiff(old_names, names)
[17:28:18.583]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.583]                   envs[common]]
[17:28:18.583]                 NAMES <- toupper(changed)
[17:28:18.583]                 args <- list()
[17:28:18.583]                 for (kk in seq_along(NAMES)) {
[17:28:18.583]                   name <- changed[[kk]]
[17:28:18.583]                   NAME <- NAMES[[kk]]
[17:28:18.583]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.583]                     next
[17:28:18.583]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.583]                 }
[17:28:18.583]                 NAMES <- toupper(added)
[17:28:18.583]                 for (kk in seq_along(NAMES)) {
[17:28:18.583]                   name <- added[[kk]]
[17:28:18.583]                   NAME <- NAMES[[kk]]
[17:28:18.583]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.583]                     next
[17:28:18.583]                   args[[name]] <- ""
[17:28:18.583]                 }
[17:28:18.583]                 NAMES <- toupper(removed)
[17:28:18.583]                 for (kk in seq_along(NAMES)) {
[17:28:18.583]                   name <- removed[[kk]]
[17:28:18.583]                   NAME <- NAMES[[kk]]
[17:28:18.583]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.583]                     next
[17:28:18.583]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.583]                 }
[17:28:18.583]                 if (length(args) > 0) 
[17:28:18.583]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.583]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.583]             }
[17:28:18.583]             else {
[17:28:18.583]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.583]             }
[17:28:18.583]             {
[17:28:18.583]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.583]                   0L) {
[17:28:18.583]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.583]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.583]                   base::options(opts)
[17:28:18.583]                 }
[17:28:18.583]                 {
[17:28:18.583]                   {
[17:28:18.583]                     base::assign(".Random.seed", c(10407L, 817755046L, 
[17:28:18.583]                     -1167101805L, -1019604937L, -1013881922L, 
[17:28:18.583]                     1345551017L, 1896942424L), envir = base::globalenv(), 
[17:28:18.583]                       inherits = FALSE)
[17:28:18.583]                     NULL
[17:28:18.583]                   }
[17:28:18.583]                   options(future.plan = NULL)
[17:28:18.583]                   if (is.na(NA_character_)) 
[17:28:18.583]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.583]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.583]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.583]                     .init = FALSE)
[17:28:18.583]                 }
[17:28:18.583]             }
[17:28:18.583]         }
[17:28:18.583]     })
[17:28:18.583]     if (TRUE) {
[17:28:18.583]         base::sink(type = "output", split = FALSE)
[17:28:18.583]         if (TRUE) {
[17:28:18.583]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.583]         }
[17:28:18.583]         else {
[17:28:18.583]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.583]         }
[17:28:18.583]         base::close(...future.stdout)
[17:28:18.583]         ...future.stdout <- NULL
[17:28:18.583]     }
[17:28:18.583]     ...future.result$conditions <- ...future.conditions
[17:28:18.583]     ...future.result$finished <- base::Sys.time()
[17:28:18.583]     ...future.result
[17:28:18.583] }
[17:28:18.587] assign_globals() ...
[17:28:18.587] List of 1
[17:28:18.587]  $ x: int [1:4] 0 1 2 3
[17:28:18.587]  - attr(*, "where")=List of 1
[17:28:18.587]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.587]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.587]  - attr(*, "resolved")= logi FALSE
[17:28:18.587]  - attr(*, "total_size")= num 64
[17:28:18.587]  - attr(*, "already-done")= logi TRUE
[17:28:18.590] - copied 'x' to environment
[17:28:18.590] assign_globals() ... done
[17:28:18.591] plan(): Setting new future strategy stack:
[17:28:18.591] List of future strategies:
[17:28:18.591] 1. sequential:
[17:28:18.591]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.591]    - tweaked: FALSE
[17:28:18.591]    - call: NULL
[17:28:18.591] plan(): nbrOfWorkers() = 1
[17:28:18.593] plan(): Setting new future strategy stack:
[17:28:18.593] List of future strategies:
[17:28:18.593] 1. sequential:
[17:28:18.593]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.593]    - tweaked: FALSE
[17:28:18.593]    - call: plan(strategy)
[17:28:18.593] plan(): nbrOfWorkers() = 1
[17:28:18.594] SequentialFuture started (and completed)
[17:28:18.594] - Launch lazy future ... done
[17:28:18.594] run() for 'SequentialFuture' ... done
[17:28:18.595] getGlobalsAndPackages() ...
[17:28:18.595] Searching for globals...
[17:28:18.596] - globals found: [3] '{', 'sample', 'x'
[17:28:18.596] Searching for globals ... DONE
[17:28:18.597] Resolving globals: FALSE
[17:28:18.598] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.598] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.598] - globals: [1] 'x'
[17:28:18.599] 
[17:28:18.599] getGlobalsAndPackages() ... DONE
[17:28:18.599] run() for 'Future' ...
[17:28:18.599] - state: 'created'
[17:28:18.600] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.600] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.600] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.600]   - Field: 'label'
[17:28:18.600]   - Field: 'local'
[17:28:18.601]   - Field: 'owner'
[17:28:18.601]   - Field: 'envir'
[17:28:18.601]   - Field: 'packages'
[17:28:18.601]   - Field: 'gc'
[17:28:18.601]   - Field: 'conditions'
[17:28:18.602]   - Field: 'expr'
[17:28:18.602]   - Field: 'uuid'
[17:28:18.602]   - Field: 'seed'
[17:28:18.602]   - Field: 'version'
[17:28:18.602]   - Field: 'result'
[17:28:18.602]   - Field: 'asynchronous'
[17:28:18.603]   - Field: 'calls'
[17:28:18.603]   - Field: 'globals'
[17:28:18.603]   - Field: 'stdout'
[17:28:18.603]   - Field: 'earlySignal'
[17:28:18.603]   - Field: 'lazy'
[17:28:18.603]   - Field: 'state'
[17:28:18.604] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.604] - Launch lazy future ...
[17:28:18.604] Packages needed by the future expression (n = 0): <none>
[17:28:18.604] Packages needed by future strategies (n = 0): <none>
[17:28:18.605] {
[17:28:18.605]     {
[17:28:18.605]         {
[17:28:18.605]             ...future.startTime <- base::Sys.time()
[17:28:18.605]             {
[17:28:18.605]                 {
[17:28:18.605]                   {
[17:28:18.605]                     base::local({
[17:28:18.605]                       has_future <- base::requireNamespace("future", 
[17:28:18.605]                         quietly = TRUE)
[17:28:18.605]                       if (has_future) {
[17:28:18.605]                         ns <- base::getNamespace("future")
[17:28:18.605]                         version <- ns[[".package"]][["version"]]
[17:28:18.605]                         if (is.null(version)) 
[17:28:18.605]                           version <- utils::packageVersion("future")
[17:28:18.605]                       }
[17:28:18.605]                       else {
[17:28:18.605]                         version <- NULL
[17:28:18.605]                       }
[17:28:18.605]                       if (!has_future || version < "1.8.0") {
[17:28:18.605]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.605]                           "", base::R.version$version.string), 
[17:28:18.605]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.605]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.605]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.605]                             "release", "version")], collapse = " "), 
[17:28:18.605]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.605]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.605]                           info)
[17:28:18.605]                         info <- base::paste(info, collapse = "; ")
[17:28:18.605]                         if (!has_future) {
[17:28:18.605]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.605]                             info)
[17:28:18.605]                         }
[17:28:18.605]                         else {
[17:28:18.605]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.605]                             info, version)
[17:28:18.605]                         }
[17:28:18.605]                         base::stop(msg)
[17:28:18.605]                       }
[17:28:18.605]                     })
[17:28:18.605]                   }
[17:28:18.605]                   ...future.strategy.old <- future::plan("list")
[17:28:18.605]                   options(future.plan = NULL)
[17:28:18.605]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.605]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.605]                 }
[17:28:18.605]                 ...future.workdir <- getwd()
[17:28:18.605]             }
[17:28:18.605]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.605]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.605]         }
[17:28:18.605]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.605]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.605]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.605]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.605]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.605]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.605]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.605]             base::names(...future.oldOptions))
[17:28:18.605]     }
[17:28:18.605]     if (FALSE) {
[17:28:18.605]     }
[17:28:18.605]     else {
[17:28:18.605]         if (TRUE) {
[17:28:18.605]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.605]                 open = "w")
[17:28:18.605]         }
[17:28:18.605]         else {
[17:28:18.605]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.605]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.605]         }
[17:28:18.605]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.605]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.605]             base::sink(type = "output", split = FALSE)
[17:28:18.605]             base::close(...future.stdout)
[17:28:18.605]         }, add = TRUE)
[17:28:18.605]     }
[17:28:18.605]     ...future.frame <- base::sys.nframe()
[17:28:18.605]     ...future.conditions <- base::list()
[17:28:18.605]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.605]     if (FALSE) {
[17:28:18.605]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.605]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.605]     }
[17:28:18.605]     ...future.result <- base::tryCatch({
[17:28:18.605]         base::withCallingHandlers({
[17:28:18.605]             ...future.value <- base::withVisible(base::local({
[17:28:18.605]                 sample(x, size = 1L)
[17:28:18.605]             }))
[17:28:18.605]             future::FutureResult(value = ...future.value$value, 
[17:28:18.605]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.605]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.605]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.605]                     ...future.globalenv.names))
[17:28:18.605]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.605]         }, condition = base::local({
[17:28:18.605]             c <- base::c
[17:28:18.605]             inherits <- base::inherits
[17:28:18.605]             invokeRestart <- base::invokeRestart
[17:28:18.605]             length <- base::length
[17:28:18.605]             list <- base::list
[17:28:18.605]             seq.int <- base::seq.int
[17:28:18.605]             signalCondition <- base::signalCondition
[17:28:18.605]             sys.calls <- base::sys.calls
[17:28:18.605]             `[[` <- base::`[[`
[17:28:18.605]             `+` <- base::`+`
[17:28:18.605]             `<<-` <- base::`<<-`
[17:28:18.605]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.605]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.605]                   3L)]
[17:28:18.605]             }
[17:28:18.605]             function(cond) {
[17:28:18.605]                 is_error <- inherits(cond, "error")
[17:28:18.605]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.605]                   NULL)
[17:28:18.605]                 if (is_error) {
[17:28:18.605]                   sessionInformation <- function() {
[17:28:18.605]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.605]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.605]                       search = base::search(), system = base::Sys.info())
[17:28:18.605]                   }
[17:28:18.605]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.605]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.605]                     cond$call), session = sessionInformation(), 
[17:28:18.605]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.605]                   signalCondition(cond)
[17:28:18.605]                 }
[17:28:18.605]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.605]                 "immediateCondition"))) {
[17:28:18.605]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.605]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.605]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.605]                   if (TRUE && !signal) {
[17:28:18.605]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.605]                     {
[17:28:18.605]                       inherits <- base::inherits
[17:28:18.605]                       invokeRestart <- base::invokeRestart
[17:28:18.605]                       is.null <- base::is.null
[17:28:18.605]                       muffled <- FALSE
[17:28:18.605]                       if (inherits(cond, "message")) {
[17:28:18.605]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.605]                         if (muffled) 
[17:28:18.605]                           invokeRestart("muffleMessage")
[17:28:18.605]                       }
[17:28:18.605]                       else if (inherits(cond, "warning")) {
[17:28:18.605]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.605]                         if (muffled) 
[17:28:18.605]                           invokeRestart("muffleWarning")
[17:28:18.605]                       }
[17:28:18.605]                       else if (inherits(cond, "condition")) {
[17:28:18.605]                         if (!is.null(pattern)) {
[17:28:18.605]                           computeRestarts <- base::computeRestarts
[17:28:18.605]                           grepl <- base::grepl
[17:28:18.605]                           restarts <- computeRestarts(cond)
[17:28:18.605]                           for (restart in restarts) {
[17:28:18.605]                             name <- restart$name
[17:28:18.605]                             if (is.null(name)) 
[17:28:18.605]                               next
[17:28:18.605]                             if (!grepl(pattern, name)) 
[17:28:18.605]                               next
[17:28:18.605]                             invokeRestart(restart)
[17:28:18.605]                             muffled <- TRUE
[17:28:18.605]                             break
[17:28:18.605]                           }
[17:28:18.605]                         }
[17:28:18.605]                       }
[17:28:18.605]                       invisible(muffled)
[17:28:18.605]                     }
[17:28:18.605]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.605]                   }
[17:28:18.605]                 }
[17:28:18.605]                 else {
[17:28:18.605]                   if (TRUE) {
[17:28:18.605]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.605]                     {
[17:28:18.605]                       inherits <- base::inherits
[17:28:18.605]                       invokeRestart <- base::invokeRestart
[17:28:18.605]                       is.null <- base::is.null
[17:28:18.605]                       muffled <- FALSE
[17:28:18.605]                       if (inherits(cond, "message")) {
[17:28:18.605]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.605]                         if (muffled) 
[17:28:18.605]                           invokeRestart("muffleMessage")
[17:28:18.605]                       }
[17:28:18.605]                       else if (inherits(cond, "warning")) {
[17:28:18.605]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.605]                         if (muffled) 
[17:28:18.605]                           invokeRestart("muffleWarning")
[17:28:18.605]                       }
[17:28:18.605]                       else if (inherits(cond, "condition")) {
[17:28:18.605]                         if (!is.null(pattern)) {
[17:28:18.605]                           computeRestarts <- base::computeRestarts
[17:28:18.605]                           grepl <- base::grepl
[17:28:18.605]                           restarts <- computeRestarts(cond)
[17:28:18.605]                           for (restart in restarts) {
[17:28:18.605]                             name <- restart$name
[17:28:18.605]                             if (is.null(name)) 
[17:28:18.605]                               next
[17:28:18.605]                             if (!grepl(pattern, name)) 
[17:28:18.605]                               next
[17:28:18.605]                             invokeRestart(restart)
[17:28:18.605]                             muffled <- TRUE
[17:28:18.605]                             break
[17:28:18.605]                           }
[17:28:18.605]                         }
[17:28:18.605]                       }
[17:28:18.605]                       invisible(muffled)
[17:28:18.605]                     }
[17:28:18.605]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.605]                   }
[17:28:18.605]                 }
[17:28:18.605]             }
[17:28:18.605]         }))
[17:28:18.605]     }, error = function(ex) {
[17:28:18.605]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.605]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.605]                 ...future.rng), started = ...future.startTime, 
[17:28:18.605]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.605]             version = "1.8"), class = "FutureResult")
[17:28:18.605]     }, finally = {
[17:28:18.605]         if (!identical(...future.workdir, getwd())) 
[17:28:18.605]             setwd(...future.workdir)
[17:28:18.605]         {
[17:28:18.605]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.605]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.605]             }
[17:28:18.605]             base::options(...future.oldOptions)
[17:28:18.605]             if (.Platform$OS.type == "windows") {
[17:28:18.605]                 old_names <- names(...future.oldEnvVars)
[17:28:18.605]                 envs <- base::Sys.getenv()
[17:28:18.605]                 names <- names(envs)
[17:28:18.605]                 common <- intersect(names, old_names)
[17:28:18.605]                 added <- setdiff(names, old_names)
[17:28:18.605]                 removed <- setdiff(old_names, names)
[17:28:18.605]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.605]                   envs[common]]
[17:28:18.605]                 NAMES <- toupper(changed)
[17:28:18.605]                 args <- list()
[17:28:18.605]                 for (kk in seq_along(NAMES)) {
[17:28:18.605]                   name <- changed[[kk]]
[17:28:18.605]                   NAME <- NAMES[[kk]]
[17:28:18.605]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.605]                     next
[17:28:18.605]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.605]                 }
[17:28:18.605]                 NAMES <- toupper(added)
[17:28:18.605]                 for (kk in seq_along(NAMES)) {
[17:28:18.605]                   name <- added[[kk]]
[17:28:18.605]                   NAME <- NAMES[[kk]]
[17:28:18.605]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.605]                     next
[17:28:18.605]                   args[[name]] <- ""
[17:28:18.605]                 }
[17:28:18.605]                 NAMES <- toupper(removed)
[17:28:18.605]                 for (kk in seq_along(NAMES)) {
[17:28:18.605]                   name <- removed[[kk]]
[17:28:18.605]                   NAME <- NAMES[[kk]]
[17:28:18.605]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.605]                     next
[17:28:18.605]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.605]                 }
[17:28:18.605]                 if (length(args) > 0) 
[17:28:18.605]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.605]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.605]             }
[17:28:18.605]             else {
[17:28:18.605]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.605]             }
[17:28:18.605]             {
[17:28:18.605]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.605]                   0L) {
[17:28:18.605]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.605]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.605]                   base::options(opts)
[17:28:18.605]                 }
[17:28:18.605]                 {
[17:28:18.605]                   {
[17:28:18.605]                     base::assign(".Random.seed", c(10407L, -1019604937L, 
[17:28:18.605]                     -34713735L, -1667216435L, 1896942424L, 740037062L, 
[17:28:18.605]                     -783328168L), envir = base::globalenv(), 
[17:28:18.605]                       inherits = FALSE)
[17:28:18.605]                     NULL
[17:28:18.605]                   }
[17:28:18.605]                   options(future.plan = NULL)
[17:28:18.605]                   if (is.na(NA_character_)) 
[17:28:18.605]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.605]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.605]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.605]                     .init = FALSE)
[17:28:18.605]                 }
[17:28:18.605]             }
[17:28:18.605]         }
[17:28:18.605]     })
[17:28:18.605]     if (TRUE) {
[17:28:18.605]         base::sink(type = "output", split = FALSE)
[17:28:18.605]         if (TRUE) {
[17:28:18.605]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.605]         }
[17:28:18.605]         else {
[17:28:18.605]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.605]         }
[17:28:18.605]         base::close(...future.stdout)
[17:28:18.605]         ...future.stdout <- NULL
[17:28:18.605]     }
[17:28:18.605]     ...future.result$conditions <- ...future.conditions
[17:28:18.605]     ...future.result$finished <- base::Sys.time()
[17:28:18.605]     ...future.result
[17:28:18.605] }
[17:28:18.608] assign_globals() ...
[17:28:18.609] List of 1
[17:28:18.609]  $ x: int [1:4] 0 1 2 3
[17:28:18.609]  - attr(*, "where")=List of 1
[17:28:18.609]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.609]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.609]  - attr(*, "resolved")= logi FALSE
[17:28:18.609]  - attr(*, "total_size")= num 64
[17:28:18.609]  - attr(*, "already-done")= logi TRUE
[17:28:18.611] - copied 'x' to environment
[17:28:18.612] assign_globals() ... done
[17:28:18.612] plan(): Setting new future strategy stack:
[17:28:18.612] List of future strategies:
[17:28:18.612] 1. sequential:
[17:28:18.612]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.612]    - tweaked: FALSE
[17:28:18.612]    - call: NULL
[17:28:18.613] plan(): nbrOfWorkers() = 1
[17:28:18.614] plan(): Setting new future strategy stack:
[17:28:18.614] List of future strategies:
[17:28:18.614] 1. sequential:
[17:28:18.614]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.614]    - tweaked: FALSE
[17:28:18.614]    - call: plan(strategy)
[17:28:18.615] plan(): nbrOfWorkers() = 1
[17:28:18.615] SequentialFuture started (and completed)
[17:28:18.615] - Launch lazy future ... done
[17:28:18.615] run() for 'SequentialFuture' ... done
[17:28:18.616] getGlobalsAndPackages() ...
[17:28:18.616] Searching for globals...
[17:28:18.617] - globals found: [3] '{', 'sample', 'x'
[17:28:18.617] Searching for globals ... DONE
[17:28:18.617] Resolving globals: FALSE
[17:28:18.618] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:18.618] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:18.618] - globals: [1] 'x'
[17:28:18.619] 
[17:28:18.619] getGlobalsAndPackages() ... DONE
[17:28:18.619] run() for 'Future' ...
[17:28:18.619] - state: 'created'
[17:28:18.620] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:18.620] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:18.620] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:18.620]   - Field: 'label'
[17:28:18.620]   - Field: 'local'
[17:28:18.621]   - Field: 'owner'
[17:28:18.621]   - Field: 'envir'
[17:28:18.621]   - Field: 'packages'
[17:28:18.621]   - Field: 'gc'
[17:28:18.621]   - Field: 'conditions'
[17:28:18.621]   - Field: 'expr'
[17:28:18.622]   - Field: 'uuid'
[17:28:18.622]   - Field: 'seed'
[17:28:18.622]   - Field: 'version'
[17:28:18.622]   - Field: 'result'
[17:28:18.622]   - Field: 'asynchronous'
[17:28:18.622]   - Field: 'calls'
[17:28:18.623]   - Field: 'globals'
[17:28:18.623]   - Field: 'stdout'
[17:28:18.623]   - Field: 'earlySignal'
[17:28:18.623]   - Field: 'lazy'
[17:28:18.623]   - Field: 'state'
[17:28:18.624] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:18.624] - Launch lazy future ...
[17:28:18.624] Packages needed by the future expression (n = 0): <none>
[17:28:18.624] Packages needed by future strategies (n = 0): <none>
[17:28:18.626] {
[17:28:18.626]     {
[17:28:18.626]         {
[17:28:18.626]             ...future.startTime <- base::Sys.time()
[17:28:18.626]             {
[17:28:18.626]                 {
[17:28:18.626]                   {
[17:28:18.626]                     base::local({
[17:28:18.626]                       has_future <- base::requireNamespace("future", 
[17:28:18.626]                         quietly = TRUE)
[17:28:18.626]                       if (has_future) {
[17:28:18.626]                         ns <- base::getNamespace("future")
[17:28:18.626]                         version <- ns[[".package"]][["version"]]
[17:28:18.626]                         if (is.null(version)) 
[17:28:18.626]                           version <- utils::packageVersion("future")
[17:28:18.626]                       }
[17:28:18.626]                       else {
[17:28:18.626]                         version <- NULL
[17:28:18.626]                       }
[17:28:18.626]                       if (!has_future || version < "1.8.0") {
[17:28:18.626]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:18.626]                           "", base::R.version$version.string), 
[17:28:18.626]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:18.626]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:18.626]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:18.626]                             "release", "version")], collapse = " "), 
[17:28:18.626]                           hostname = base::Sys.info()[["nodename"]])
[17:28:18.626]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:18.626]                           info)
[17:28:18.626]                         info <- base::paste(info, collapse = "; ")
[17:28:18.626]                         if (!has_future) {
[17:28:18.626]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:18.626]                             info)
[17:28:18.626]                         }
[17:28:18.626]                         else {
[17:28:18.626]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:18.626]                             info, version)
[17:28:18.626]                         }
[17:28:18.626]                         base::stop(msg)
[17:28:18.626]                       }
[17:28:18.626]                     })
[17:28:18.626]                   }
[17:28:18.626]                   ...future.strategy.old <- future::plan("list")
[17:28:18.626]                   options(future.plan = NULL)
[17:28:18.626]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.626]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:18.626]                 }
[17:28:18.626]                 ...future.workdir <- getwd()
[17:28:18.626]             }
[17:28:18.626]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:18.626]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:18.626]         }
[17:28:18.626]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:18.626]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:18.626]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:18.626]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:18.626]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:18.626]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:18.626]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:18.626]             base::names(...future.oldOptions))
[17:28:18.626]     }
[17:28:18.626]     if (FALSE) {
[17:28:18.626]     }
[17:28:18.626]     else {
[17:28:18.626]         if (TRUE) {
[17:28:18.626]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:18.626]                 open = "w")
[17:28:18.626]         }
[17:28:18.626]         else {
[17:28:18.626]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:18.626]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:18.626]         }
[17:28:18.626]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:18.626]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:18.626]             base::sink(type = "output", split = FALSE)
[17:28:18.626]             base::close(...future.stdout)
[17:28:18.626]         }, add = TRUE)
[17:28:18.626]     }
[17:28:18.626]     ...future.frame <- base::sys.nframe()
[17:28:18.626]     ...future.conditions <- base::list()
[17:28:18.626]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:18.626]     if (FALSE) {
[17:28:18.626]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:18.626]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:18.626]     }
[17:28:18.626]     ...future.result <- base::tryCatch({
[17:28:18.626]         base::withCallingHandlers({
[17:28:18.626]             ...future.value <- base::withVisible(base::local({
[17:28:18.626]                 sample(x, size = 1L)
[17:28:18.626]             }))
[17:28:18.626]             future::FutureResult(value = ...future.value$value, 
[17:28:18.626]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.626]                   ...future.rng), globalenv = if (FALSE) 
[17:28:18.626]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:18.626]                     ...future.globalenv.names))
[17:28:18.626]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:18.626]         }, condition = base::local({
[17:28:18.626]             c <- base::c
[17:28:18.626]             inherits <- base::inherits
[17:28:18.626]             invokeRestart <- base::invokeRestart
[17:28:18.626]             length <- base::length
[17:28:18.626]             list <- base::list
[17:28:18.626]             seq.int <- base::seq.int
[17:28:18.626]             signalCondition <- base::signalCondition
[17:28:18.626]             sys.calls <- base::sys.calls
[17:28:18.626]             `[[` <- base::`[[`
[17:28:18.626]             `+` <- base::`+`
[17:28:18.626]             `<<-` <- base::`<<-`
[17:28:18.626]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:18.626]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:18.626]                   3L)]
[17:28:18.626]             }
[17:28:18.626]             function(cond) {
[17:28:18.626]                 is_error <- inherits(cond, "error")
[17:28:18.626]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:18.626]                   NULL)
[17:28:18.626]                 if (is_error) {
[17:28:18.626]                   sessionInformation <- function() {
[17:28:18.626]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:18.626]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:18.626]                       search = base::search(), system = base::Sys.info())
[17:28:18.626]                   }
[17:28:18.626]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.626]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:18.626]                     cond$call), session = sessionInformation(), 
[17:28:18.626]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:18.626]                   signalCondition(cond)
[17:28:18.626]                 }
[17:28:18.626]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:18.626]                 "immediateCondition"))) {
[17:28:18.626]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:18.626]                   ...future.conditions[[length(...future.conditions) + 
[17:28:18.626]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:18.626]                   if (TRUE && !signal) {
[17:28:18.626]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.626]                     {
[17:28:18.626]                       inherits <- base::inherits
[17:28:18.626]                       invokeRestart <- base::invokeRestart
[17:28:18.626]                       is.null <- base::is.null
[17:28:18.626]                       muffled <- FALSE
[17:28:18.626]                       if (inherits(cond, "message")) {
[17:28:18.626]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.626]                         if (muffled) 
[17:28:18.626]                           invokeRestart("muffleMessage")
[17:28:18.626]                       }
[17:28:18.626]                       else if (inherits(cond, "warning")) {
[17:28:18.626]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.626]                         if (muffled) 
[17:28:18.626]                           invokeRestart("muffleWarning")
[17:28:18.626]                       }
[17:28:18.626]                       else if (inherits(cond, "condition")) {
[17:28:18.626]                         if (!is.null(pattern)) {
[17:28:18.626]                           computeRestarts <- base::computeRestarts
[17:28:18.626]                           grepl <- base::grepl
[17:28:18.626]                           restarts <- computeRestarts(cond)
[17:28:18.626]                           for (restart in restarts) {
[17:28:18.626]                             name <- restart$name
[17:28:18.626]                             if (is.null(name)) 
[17:28:18.626]                               next
[17:28:18.626]                             if (!grepl(pattern, name)) 
[17:28:18.626]                               next
[17:28:18.626]                             invokeRestart(restart)
[17:28:18.626]                             muffled <- TRUE
[17:28:18.626]                             break
[17:28:18.626]                           }
[17:28:18.626]                         }
[17:28:18.626]                       }
[17:28:18.626]                       invisible(muffled)
[17:28:18.626]                     }
[17:28:18.626]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.626]                   }
[17:28:18.626]                 }
[17:28:18.626]                 else {
[17:28:18.626]                   if (TRUE) {
[17:28:18.626]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:18.626]                     {
[17:28:18.626]                       inherits <- base::inherits
[17:28:18.626]                       invokeRestart <- base::invokeRestart
[17:28:18.626]                       is.null <- base::is.null
[17:28:18.626]                       muffled <- FALSE
[17:28:18.626]                       if (inherits(cond, "message")) {
[17:28:18.626]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:18.626]                         if (muffled) 
[17:28:18.626]                           invokeRestart("muffleMessage")
[17:28:18.626]                       }
[17:28:18.626]                       else if (inherits(cond, "warning")) {
[17:28:18.626]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:18.626]                         if (muffled) 
[17:28:18.626]                           invokeRestart("muffleWarning")
[17:28:18.626]                       }
[17:28:18.626]                       else if (inherits(cond, "condition")) {
[17:28:18.626]                         if (!is.null(pattern)) {
[17:28:18.626]                           computeRestarts <- base::computeRestarts
[17:28:18.626]                           grepl <- base::grepl
[17:28:18.626]                           restarts <- computeRestarts(cond)
[17:28:18.626]                           for (restart in restarts) {
[17:28:18.626]                             name <- restart$name
[17:28:18.626]                             if (is.null(name)) 
[17:28:18.626]                               next
[17:28:18.626]                             if (!grepl(pattern, name)) 
[17:28:18.626]                               next
[17:28:18.626]                             invokeRestart(restart)
[17:28:18.626]                             muffled <- TRUE
[17:28:18.626]                             break
[17:28:18.626]                           }
[17:28:18.626]                         }
[17:28:18.626]                       }
[17:28:18.626]                       invisible(muffled)
[17:28:18.626]                     }
[17:28:18.626]                     muffleCondition(cond, pattern = "^muffle")
[17:28:18.626]                   }
[17:28:18.626]                 }
[17:28:18.626]             }
[17:28:18.626]         }))
[17:28:18.626]     }, error = function(ex) {
[17:28:18.626]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:18.626]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:18.626]                 ...future.rng), started = ...future.startTime, 
[17:28:18.626]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:18.626]             version = "1.8"), class = "FutureResult")
[17:28:18.626]     }, finally = {
[17:28:18.626]         if (!identical(...future.workdir, getwd())) 
[17:28:18.626]             setwd(...future.workdir)
[17:28:18.626]         {
[17:28:18.626]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:18.626]                 ...future.oldOptions$nwarnings <- NULL
[17:28:18.626]             }
[17:28:18.626]             base::options(...future.oldOptions)
[17:28:18.626]             if (.Platform$OS.type == "windows") {
[17:28:18.626]                 old_names <- names(...future.oldEnvVars)
[17:28:18.626]                 envs <- base::Sys.getenv()
[17:28:18.626]                 names <- names(envs)
[17:28:18.626]                 common <- intersect(names, old_names)
[17:28:18.626]                 added <- setdiff(names, old_names)
[17:28:18.626]                 removed <- setdiff(old_names, names)
[17:28:18.626]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:18.626]                   envs[common]]
[17:28:18.626]                 NAMES <- toupper(changed)
[17:28:18.626]                 args <- list()
[17:28:18.626]                 for (kk in seq_along(NAMES)) {
[17:28:18.626]                   name <- changed[[kk]]
[17:28:18.626]                   NAME <- NAMES[[kk]]
[17:28:18.626]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.626]                     next
[17:28:18.626]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.626]                 }
[17:28:18.626]                 NAMES <- toupper(added)
[17:28:18.626]                 for (kk in seq_along(NAMES)) {
[17:28:18.626]                   name <- added[[kk]]
[17:28:18.626]                   NAME <- NAMES[[kk]]
[17:28:18.626]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.626]                     next
[17:28:18.626]                   args[[name]] <- ""
[17:28:18.626]                 }
[17:28:18.626]                 NAMES <- toupper(removed)
[17:28:18.626]                 for (kk in seq_along(NAMES)) {
[17:28:18.626]                   name <- removed[[kk]]
[17:28:18.626]                   NAME <- NAMES[[kk]]
[17:28:18.626]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:18.626]                     next
[17:28:18.626]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:18.626]                 }
[17:28:18.626]                 if (length(args) > 0) 
[17:28:18.626]                   base::do.call(base::Sys.setenv, args = args)
[17:28:18.626]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:18.626]             }
[17:28:18.626]             else {
[17:28:18.626]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:18.626]             }
[17:28:18.626]             {
[17:28:18.626]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:18.626]                   0L) {
[17:28:18.626]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:18.626]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:18.626]                   base::options(opts)
[17:28:18.626]                 }
[17:28:18.626]                 {
[17:28:18.626]                   {
[17:28:18.626]                     base::assign(".Random.seed", c(10407L, -1667216435L, 
[17:28:18.626]                     -1252731658L, 1120344904L, -783328168L, -1236028416L, 
[17:28:18.626]                     -1054736142L), envir = base::globalenv(), 
[17:28:18.626]                       inherits = FALSE)
[17:28:18.626]                     NULL
[17:28:18.626]                   }
[17:28:18.626]                   options(future.plan = NULL)
[17:28:18.626]                   if (is.na(NA_character_)) 
[17:28:18.626]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:18.626]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:18.626]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:18.626]                     .init = FALSE)
[17:28:18.626]                 }
[17:28:18.626]             }
[17:28:18.626]         }
[17:28:18.626]     })
[17:28:18.626]     if (TRUE) {
[17:28:18.626]         base::sink(type = "output", split = FALSE)
[17:28:18.626]         if (TRUE) {
[17:28:18.626]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:18.626]         }
[17:28:18.626]         else {
[17:28:18.626]             ...future.result["stdout"] <- base::list(NULL)
[17:28:18.626]         }
[17:28:18.626]         base::close(...future.stdout)
[17:28:18.626]         ...future.stdout <- NULL
[17:28:18.626]     }
[17:28:18.626]     ...future.result$conditions <- ...future.conditions
[17:28:18.626]     ...future.result$finished <- base::Sys.time()
[17:28:18.626]     ...future.result
[17:28:18.626] }
[17:28:18.630] assign_globals() ...
[17:28:18.630] List of 1
[17:28:18.630]  $ x: int [1:4] 0 1 2 3
[17:28:18.630]  - attr(*, "where")=List of 1
[17:28:18.630]   ..$ x:<environment: R_EmptyEnv> 
[17:28:18.630]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:18.630]  - attr(*, "resolved")= logi FALSE
[17:28:18.630]  - attr(*, "total_size")= num 64
[17:28:18.630]  - attr(*, "already-done")= logi TRUE
[17:28:18.633] - copied 'x' to environment
[17:28:18.633] assign_globals() ... done
[17:28:18.633] plan(): Setting new future strategy stack:
[17:28:18.634] List of future strategies:
[17:28:18.634] 1. sequential:
[17:28:18.634]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.634]    - tweaked: FALSE
[17:28:18.634]    - call: NULL
[17:28:18.634] plan(): nbrOfWorkers() = 1
[17:28:18.635] plan(): Setting new future strategy stack:
[17:28:18.636] List of future strategies:
[17:28:18.636] 1. sequential:
[17:28:18.636]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:18.636]    - tweaked: FALSE
[17:28:18.636]    - call: plan(strategy)
[17:28:18.636] plan(): nbrOfWorkers() = 1
[17:28:18.636] SequentialFuture started (and completed)
[17:28:18.637] - Launch lazy future ... done
[17:28:18.637] run() for 'SequentialFuture' ... done
[[1]]
[1] 3

[[2]]
[1] 2

[[3]]
[1] 1

[[4]]
[1] 3

sequential ... done
Testing with 1 cores ... DONE
Testing with 2 cores ...
multisession ...
[17:28:18.643] plan(): Setting new future strategy stack:
[17:28:18.644] List of future strategies:
[17:28:18.644] 1. multisession:
[17:28:18.644]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:28:18.644]    - tweaked: FALSE
[17:28:18.644]    - call: plan(strategy)
[17:28:18.644] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:28:18.644] multisession:
[17:28:18.644] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:28:18.644] - tweaked: FALSE
[17:28:18.644] - call: plan(strategy)
[17:28:18.648] getGlobalsAndPackages() ...
[17:28:18.649] Not searching for globals
[17:28:18.649] - globals: [0] <none>
[17:28:18.649] getGlobalsAndPackages() ... DONE
[17:28:18.651] [local output] makeClusterPSOCK() ...
[17:28:18.684] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:28:18.690] [local output] Base port: 34689
[17:28:18.691] [local output] Getting setup options for 2 cluster nodes ...
[17:28:18.691] [local output]  - Node 1 of 2 ...
[17:28:18.691] [local output] localMachine=TRUE => revtunnel=FALSE

[17:28:18.693] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpWemDxE/worker.rank=1.parallelly.parent=149920.249a031d77151.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpWemDxE/worker.rank=1.parallelly.parent=149920.249a031d77151.pid\")"'
[17:28:19.031] - Possible to infer worker's PID: TRUE
[17:28:19.032] [local output] Rscript port: 34689

[17:28:19.032] [local output]  - Node 2 of 2 ...
[17:28:19.033] [local output] localMachine=TRUE => revtunnel=FALSE

[17:28:19.034] [local output] Rscript port: 34689

[17:28:19.034] [local output] Getting setup options for 2 cluster nodes ... done
[17:28:19.034] [local output]  - Parallel setup requested for some PSOCK nodes
[17:28:19.035] [local output] Setting up PSOCK nodes in parallel
[17:28:19.035] List of 36
[17:28:19.035]  $ worker          : chr "localhost"
[17:28:19.035]   ..- attr(*, "localhost")= logi TRUE
[17:28:19.035]  $ master          : chr "localhost"
[17:28:19.035]  $ port            : int 34689
[17:28:19.035]  $ connectTimeout  : num 120
[17:28:19.035]  $ timeout         : num 120
[17:28:19.035]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:28:19.035]  $ homogeneous     : logi TRUE
[17:28:19.035]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=rng.R:149920:CRANWIN3:CRAN\" -e "| __truncated__
[17:28:19.035]  $ rscript_envs    : NULL
[17:28:19.035]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7" "D:/RCompile/recent/R/library"
[17:28:19.035]  $ rscript_startup : NULL
[17:28:19.035]  $ rscript_sh      : chr "cmd"
[17:28:19.035]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:28:19.035]  $ methods         : logi TRUE
[17:28:19.035]  $ socketOptions   : chr "no-delay"
[17:28:19.035]  $ useXDR          : logi FALSE
[17:28:19.035]  $ outfile         : chr "/dev/null"
[17:28:19.035]  $ renice          : int NA
[17:28:19.035]  $ rshcmd          : NULL
[17:28:19.035]  $ user            : chr(0) 
[17:28:19.035]  $ revtunnel       : logi FALSE
[17:28:19.035]  $ rshlogfile      : NULL
[17:28:19.035]  $ rshopts         : chr(0) 
[17:28:19.035]  $ rank            : int 1
[17:28:19.035]  $ manual          : logi FALSE
[17:28:19.035]  $ dryrun          : logi FALSE
[17:28:19.035]  $ quiet           : logi FALSE
[17:28:19.035]  $ setup_strategy  : chr "parallel"
[17:28:19.035]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:28:19.035]  $ pidfile         : chr "D:/temp/RtmpWemDxE/worker.rank=1.parallelly.parent=149920.249a031d77151.pid"
[17:28:19.035]  $ rshcmd_label    : NULL
[17:28:19.035]  $ rsh_call        : NULL
[17:28:19.035]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:28:19.035]  $ localMachine    : logi TRUE
[17:28:19.035]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:28:19.035]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:28:19.035]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:28:19.035]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:28:19.035]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:28:19.035]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[17:28:19.035]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:28:19.035]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:28:19.035]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:28:19.035]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:28:19.035]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:28:19.035]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:28:19.035]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:28:19.035]  $ arguments       :List of 28
[17:28:19.035]   ..$ worker          : chr "localhost"
[17:28:19.035]   ..$ master          : NULL
[17:28:19.035]   ..$ port            : int 34689
[17:28:19.035]   ..$ connectTimeout  : num 120
[17:28:19.035]   ..$ timeout         : num 120
[17:28:19.035]   ..$ rscript         : NULL
[17:28:19.035]   ..$ homogeneous     : NULL
[17:28:19.035]   ..$ rscript_args    : NULL
[17:28:19.035]   ..$ rscript_envs    : NULL
[17:28:19.035]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7" "D:/RCompile/recent/R/library"
[17:28:19.035]   ..$ rscript_startup : NULL
[17:28:19.035]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[17:28:19.035]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:28:19.035]   ..$ methods         : logi TRUE
[17:28:19.035]   ..$ socketOptions   : chr "no-delay"
[17:28:19.035]   ..$ useXDR          : logi FALSE
[17:28:19.035]   ..$ outfile         : chr "/dev/null"
[17:28:19.035]   ..$ renice          : int NA
[17:28:19.035]   ..$ rshcmd          : NULL
[17:28:19.035]   ..$ user            : NULL
[17:28:19.035]   ..$ revtunnel       : logi NA
[17:28:19.035]   ..$ rshlogfile      : NULL
[17:28:19.035]   ..$ rshopts         : NULL
[17:28:19.035]   ..$ rank            : int 1
[17:28:19.035]   ..$ manual          : logi FALSE
[17:28:19.035]   ..$ dryrun          : logi FALSE
[17:28:19.035]   ..$ quiet           : logi FALSE
[17:28:19.035]   ..$ setup_strategy  : chr "parallel"
[17:28:19.035]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:28:19.057] [local output] System call to launch all workers:
[17:28:19.058] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=rng.R:149920:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpWemDxE/worker.rank=1.parallelly.parent=149920.249a031d77151.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=34689 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:28:19.058] [local output] Starting PSOCK main server
[17:28:19.064] [local output] Workers launched
[17:28:19.064] [local output] Waiting for workers to connect back
[17:28:19.064]  - [local output] 0 workers out of 2 ready
[17:28:19.226]  - [local output] 0 workers out of 2 ready
[17:28:19.227]  - [local output] 1 workers out of 2 ready
[17:28:19.228]  - [local output] 2 workers out of 2 ready
[17:28:19.228] [local output] Launching of workers completed
[17:28:19.228] [local output] Collecting session information from workers
[17:28:19.229] [local output]  - Worker #1 of 2
[17:28:19.230] [local output]  - Worker #2 of 2
[17:28:19.230] [local output] makeClusterPSOCK() ... done
[17:28:19.242] Packages needed by the future expression (n = 0): <none>
[17:28:19.243] Packages needed by future strategies (n = 0): <none>
[17:28:19.243] {
[17:28:19.243]     {
[17:28:19.243]         {
[17:28:19.243]             ...future.startTime <- base::Sys.time()
[17:28:19.243]             {
[17:28:19.243]                 {
[17:28:19.243]                   {
[17:28:19.243]                     {
[17:28:19.243]                       base::local({
[17:28:19.243]                         has_future <- base::requireNamespace("future", 
[17:28:19.243]                           quietly = TRUE)
[17:28:19.243]                         if (has_future) {
[17:28:19.243]                           ns <- base::getNamespace("future")
[17:28:19.243]                           version <- ns[[".package"]][["version"]]
[17:28:19.243]                           if (is.null(version)) 
[17:28:19.243]                             version <- utils::packageVersion("future")
[17:28:19.243]                         }
[17:28:19.243]                         else {
[17:28:19.243]                           version <- NULL
[17:28:19.243]                         }
[17:28:19.243]                         if (!has_future || version < "1.8.0") {
[17:28:19.243]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:19.243]                             "", base::R.version$version.string), 
[17:28:19.243]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:19.243]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:19.243]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:19.243]                               "release", "version")], collapse = " "), 
[17:28:19.243]                             hostname = base::Sys.info()[["nodename"]])
[17:28:19.243]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:19.243]                             info)
[17:28:19.243]                           info <- base::paste(info, collapse = "; ")
[17:28:19.243]                           if (!has_future) {
[17:28:19.243]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:19.243]                               info)
[17:28:19.243]                           }
[17:28:19.243]                           else {
[17:28:19.243]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:19.243]                               info, version)
[17:28:19.243]                           }
[17:28:19.243]                           base::stop(msg)
[17:28:19.243]                         }
[17:28:19.243]                       })
[17:28:19.243]                     }
[17:28:19.243]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:19.243]                     base::options(mc.cores = 1L)
[17:28:19.243]                   }
[17:28:19.243]                   ...future.strategy.old <- future::plan("list")
[17:28:19.243]                   options(future.plan = NULL)
[17:28:19.243]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.243]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:19.243]                 }
[17:28:19.243]                 ...future.workdir <- getwd()
[17:28:19.243]             }
[17:28:19.243]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:19.243]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:19.243]         }
[17:28:19.243]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:19.243]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:19.243]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:19.243]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:19.243]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:19.243]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:19.243]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:19.243]             base::names(...future.oldOptions))
[17:28:19.243]     }
[17:28:19.243]     if (FALSE) {
[17:28:19.243]     }
[17:28:19.243]     else {
[17:28:19.243]         if (TRUE) {
[17:28:19.243]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:19.243]                 open = "w")
[17:28:19.243]         }
[17:28:19.243]         else {
[17:28:19.243]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:19.243]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:19.243]         }
[17:28:19.243]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:19.243]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:19.243]             base::sink(type = "output", split = FALSE)
[17:28:19.243]             base::close(...future.stdout)
[17:28:19.243]         }, add = TRUE)
[17:28:19.243]     }
[17:28:19.243]     ...future.frame <- base::sys.nframe()
[17:28:19.243]     ...future.conditions <- base::list()
[17:28:19.243]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:19.243]     if (FALSE) {
[17:28:19.243]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:19.243]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:19.243]     }
[17:28:19.243]     ...future.result <- base::tryCatch({
[17:28:19.243]         base::withCallingHandlers({
[17:28:19.243]             ...future.value <- base::withVisible(base::local({
[17:28:19.243]                 ...future.makeSendCondition <- base::local({
[17:28:19.243]                   sendCondition <- NULL
[17:28:19.243]                   function(frame = 1L) {
[17:28:19.243]                     if (is.function(sendCondition)) 
[17:28:19.243]                       return(sendCondition)
[17:28:19.243]                     ns <- getNamespace("parallel")
[17:28:19.243]                     if (exists("sendData", mode = "function", 
[17:28:19.243]                       envir = ns)) {
[17:28:19.243]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:19.243]                         envir = ns)
[17:28:19.243]                       envir <- sys.frame(frame)
[17:28:19.243]                       master <- NULL
[17:28:19.243]                       while (!identical(envir, .GlobalEnv) && 
[17:28:19.243]                         !identical(envir, emptyenv())) {
[17:28:19.243]                         if (exists("master", mode = "list", envir = envir, 
[17:28:19.243]                           inherits = FALSE)) {
[17:28:19.243]                           master <- get("master", mode = "list", 
[17:28:19.243]                             envir = envir, inherits = FALSE)
[17:28:19.243]                           if (inherits(master, c("SOCKnode", 
[17:28:19.243]                             "SOCK0node"))) {
[17:28:19.243]                             sendCondition <<- function(cond) {
[17:28:19.243]                               data <- list(type = "VALUE", value = cond, 
[17:28:19.243]                                 success = TRUE)
[17:28:19.243]                               parallel_sendData(master, data)
[17:28:19.243]                             }
[17:28:19.243]                             return(sendCondition)
[17:28:19.243]                           }
[17:28:19.243]                         }
[17:28:19.243]                         frame <- frame + 1L
[17:28:19.243]                         envir <- sys.frame(frame)
[17:28:19.243]                       }
[17:28:19.243]                     }
[17:28:19.243]                     sendCondition <<- function(cond) NULL
[17:28:19.243]                   }
[17:28:19.243]                 })
[17:28:19.243]                 withCallingHandlers({
[17:28:19.243]                   NA
[17:28:19.243]                 }, immediateCondition = function(cond) {
[17:28:19.243]                   sendCondition <- ...future.makeSendCondition()
[17:28:19.243]                   sendCondition(cond)
[17:28:19.243]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.243]                   {
[17:28:19.243]                     inherits <- base::inherits
[17:28:19.243]                     invokeRestart <- base::invokeRestart
[17:28:19.243]                     is.null <- base::is.null
[17:28:19.243]                     muffled <- FALSE
[17:28:19.243]                     if (inherits(cond, "message")) {
[17:28:19.243]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:19.243]                       if (muffled) 
[17:28:19.243]                         invokeRestart("muffleMessage")
[17:28:19.243]                     }
[17:28:19.243]                     else if (inherits(cond, "warning")) {
[17:28:19.243]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:19.243]                       if (muffled) 
[17:28:19.243]                         invokeRestart("muffleWarning")
[17:28:19.243]                     }
[17:28:19.243]                     else if (inherits(cond, "condition")) {
[17:28:19.243]                       if (!is.null(pattern)) {
[17:28:19.243]                         computeRestarts <- base::computeRestarts
[17:28:19.243]                         grepl <- base::grepl
[17:28:19.243]                         restarts <- computeRestarts(cond)
[17:28:19.243]                         for (restart in restarts) {
[17:28:19.243]                           name <- restart$name
[17:28:19.243]                           if (is.null(name)) 
[17:28:19.243]                             next
[17:28:19.243]                           if (!grepl(pattern, name)) 
[17:28:19.243]                             next
[17:28:19.243]                           invokeRestart(restart)
[17:28:19.243]                           muffled <- TRUE
[17:28:19.243]                           break
[17:28:19.243]                         }
[17:28:19.243]                       }
[17:28:19.243]                     }
[17:28:19.243]                     invisible(muffled)
[17:28:19.243]                   }
[17:28:19.243]                   muffleCondition(cond)
[17:28:19.243]                 })
[17:28:19.243]             }))
[17:28:19.243]             future::FutureResult(value = ...future.value$value, 
[17:28:19.243]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.243]                   ...future.rng), globalenv = if (FALSE) 
[17:28:19.243]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:19.243]                     ...future.globalenv.names))
[17:28:19.243]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:19.243]         }, condition = base::local({
[17:28:19.243]             c <- base::c
[17:28:19.243]             inherits <- base::inherits
[17:28:19.243]             invokeRestart <- base::invokeRestart
[17:28:19.243]             length <- base::length
[17:28:19.243]             list <- base::list
[17:28:19.243]             seq.int <- base::seq.int
[17:28:19.243]             signalCondition <- base::signalCondition
[17:28:19.243]             sys.calls <- base::sys.calls
[17:28:19.243]             `[[` <- base::`[[`
[17:28:19.243]             `+` <- base::`+`
[17:28:19.243]             `<<-` <- base::`<<-`
[17:28:19.243]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:19.243]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:19.243]                   3L)]
[17:28:19.243]             }
[17:28:19.243]             function(cond) {
[17:28:19.243]                 is_error <- inherits(cond, "error")
[17:28:19.243]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:19.243]                   NULL)
[17:28:19.243]                 if (is_error) {
[17:28:19.243]                   sessionInformation <- function() {
[17:28:19.243]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:19.243]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:19.243]                       search = base::search(), system = base::Sys.info())
[17:28:19.243]                   }
[17:28:19.243]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.243]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:19.243]                     cond$call), session = sessionInformation(), 
[17:28:19.243]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:19.243]                   signalCondition(cond)
[17:28:19.243]                 }
[17:28:19.243]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:19.243]                 "immediateCondition"))) {
[17:28:19.243]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:19.243]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.243]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:19.243]                   if (TRUE && !signal) {
[17:28:19.243]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.243]                     {
[17:28:19.243]                       inherits <- base::inherits
[17:28:19.243]                       invokeRestart <- base::invokeRestart
[17:28:19.243]                       is.null <- base::is.null
[17:28:19.243]                       muffled <- FALSE
[17:28:19.243]                       if (inherits(cond, "message")) {
[17:28:19.243]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.243]                         if (muffled) 
[17:28:19.243]                           invokeRestart("muffleMessage")
[17:28:19.243]                       }
[17:28:19.243]                       else if (inherits(cond, "warning")) {
[17:28:19.243]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.243]                         if (muffled) 
[17:28:19.243]                           invokeRestart("muffleWarning")
[17:28:19.243]                       }
[17:28:19.243]                       else if (inherits(cond, "condition")) {
[17:28:19.243]                         if (!is.null(pattern)) {
[17:28:19.243]                           computeRestarts <- base::computeRestarts
[17:28:19.243]                           grepl <- base::grepl
[17:28:19.243]                           restarts <- computeRestarts(cond)
[17:28:19.243]                           for (restart in restarts) {
[17:28:19.243]                             name <- restart$name
[17:28:19.243]                             if (is.null(name)) 
[17:28:19.243]                               next
[17:28:19.243]                             if (!grepl(pattern, name)) 
[17:28:19.243]                               next
[17:28:19.243]                             invokeRestart(restart)
[17:28:19.243]                             muffled <- TRUE
[17:28:19.243]                             break
[17:28:19.243]                           }
[17:28:19.243]                         }
[17:28:19.243]                       }
[17:28:19.243]                       invisible(muffled)
[17:28:19.243]                     }
[17:28:19.243]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.243]                   }
[17:28:19.243]                 }
[17:28:19.243]                 else {
[17:28:19.243]                   if (TRUE) {
[17:28:19.243]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.243]                     {
[17:28:19.243]                       inherits <- base::inherits
[17:28:19.243]                       invokeRestart <- base::invokeRestart
[17:28:19.243]                       is.null <- base::is.null
[17:28:19.243]                       muffled <- FALSE
[17:28:19.243]                       if (inherits(cond, "message")) {
[17:28:19.243]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.243]                         if (muffled) 
[17:28:19.243]                           invokeRestart("muffleMessage")
[17:28:19.243]                       }
[17:28:19.243]                       else if (inherits(cond, "warning")) {
[17:28:19.243]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.243]                         if (muffled) 
[17:28:19.243]                           invokeRestart("muffleWarning")
[17:28:19.243]                       }
[17:28:19.243]                       else if (inherits(cond, "condition")) {
[17:28:19.243]                         if (!is.null(pattern)) {
[17:28:19.243]                           computeRestarts <- base::computeRestarts
[17:28:19.243]                           grepl <- base::grepl
[17:28:19.243]                           restarts <- computeRestarts(cond)
[17:28:19.243]                           for (restart in restarts) {
[17:28:19.243]                             name <- restart$name
[17:28:19.243]                             if (is.null(name)) 
[17:28:19.243]                               next
[17:28:19.243]                             if (!grepl(pattern, name)) 
[17:28:19.243]                               next
[17:28:19.243]                             invokeRestart(restart)
[17:28:19.243]                             muffled <- TRUE
[17:28:19.243]                             break
[17:28:19.243]                           }
[17:28:19.243]                         }
[17:28:19.243]                       }
[17:28:19.243]                       invisible(muffled)
[17:28:19.243]                     }
[17:28:19.243]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.243]                   }
[17:28:19.243]                 }
[17:28:19.243]             }
[17:28:19.243]         }))
[17:28:19.243]     }, error = function(ex) {
[17:28:19.243]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:19.243]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.243]                 ...future.rng), started = ...future.startTime, 
[17:28:19.243]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:19.243]             version = "1.8"), class = "FutureResult")
[17:28:19.243]     }, finally = {
[17:28:19.243]         if (!identical(...future.workdir, getwd())) 
[17:28:19.243]             setwd(...future.workdir)
[17:28:19.243]         {
[17:28:19.243]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:19.243]                 ...future.oldOptions$nwarnings <- NULL
[17:28:19.243]             }
[17:28:19.243]             base::options(...future.oldOptions)
[17:28:19.243]             if (.Platform$OS.type == "windows") {
[17:28:19.243]                 old_names <- names(...future.oldEnvVars)
[17:28:19.243]                 envs <- base::Sys.getenv()
[17:28:19.243]                 names <- names(envs)
[17:28:19.243]                 common <- intersect(names, old_names)
[17:28:19.243]                 added <- setdiff(names, old_names)
[17:28:19.243]                 removed <- setdiff(old_names, names)
[17:28:19.243]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:19.243]                   envs[common]]
[17:28:19.243]                 NAMES <- toupper(changed)
[17:28:19.243]                 args <- list()
[17:28:19.243]                 for (kk in seq_along(NAMES)) {
[17:28:19.243]                   name <- changed[[kk]]
[17:28:19.243]                   NAME <- NAMES[[kk]]
[17:28:19.243]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.243]                     next
[17:28:19.243]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.243]                 }
[17:28:19.243]                 NAMES <- toupper(added)
[17:28:19.243]                 for (kk in seq_along(NAMES)) {
[17:28:19.243]                   name <- added[[kk]]
[17:28:19.243]                   NAME <- NAMES[[kk]]
[17:28:19.243]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.243]                     next
[17:28:19.243]                   args[[name]] <- ""
[17:28:19.243]                 }
[17:28:19.243]                 NAMES <- toupper(removed)
[17:28:19.243]                 for (kk in seq_along(NAMES)) {
[17:28:19.243]                   name <- removed[[kk]]
[17:28:19.243]                   NAME <- NAMES[[kk]]
[17:28:19.243]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.243]                     next
[17:28:19.243]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.243]                 }
[17:28:19.243]                 if (length(args) > 0) 
[17:28:19.243]                   base::do.call(base::Sys.setenv, args = args)
[17:28:19.243]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:19.243]             }
[17:28:19.243]             else {
[17:28:19.243]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:19.243]             }
[17:28:19.243]             {
[17:28:19.243]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:19.243]                   0L) {
[17:28:19.243]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:19.243]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:19.243]                   base::options(opts)
[17:28:19.243]                 }
[17:28:19.243]                 {
[17:28:19.243]                   {
[17:28:19.243]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:19.243]                     NULL
[17:28:19.243]                   }
[17:28:19.243]                   options(future.plan = NULL)
[17:28:19.243]                   if (is.na(NA_character_)) 
[17:28:19.243]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.243]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:19.243]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:19.243]                     .init = FALSE)
[17:28:19.243]                 }
[17:28:19.243]             }
[17:28:19.243]         }
[17:28:19.243]     })
[17:28:19.243]     if (TRUE) {
[17:28:19.243]         base::sink(type = "output", split = FALSE)
[17:28:19.243]         if (TRUE) {
[17:28:19.243]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:19.243]         }
[17:28:19.243]         else {
[17:28:19.243]             ...future.result["stdout"] <- base::list(NULL)
[17:28:19.243]         }
[17:28:19.243]         base::close(...future.stdout)
[17:28:19.243]         ...future.stdout <- NULL
[17:28:19.243]     }
[17:28:19.243]     ...future.result$conditions <- ...future.conditions
[17:28:19.243]     ...future.result$finished <- base::Sys.time()
[17:28:19.243]     ...future.result
[17:28:19.243] }
[17:28:19.326] MultisessionFuture started
[17:28:19.326] result() for ClusterFuture ...
[17:28:19.327] receiveMessageFromWorker() for ClusterFuture ...
[17:28:19.327] - Validating connection of MultisessionFuture
[17:28:19.380] - received message: FutureResult
[17:28:19.380] - Received FutureResult
[17:28:19.384] - Erased future from FutureRegistry
[17:28:19.384] result() for ClusterFuture ...
[17:28:19.384] - result already collected: FutureResult
[17:28:19.384] result() for ClusterFuture ... done
[17:28:19.385] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:19.385] result() for ClusterFuture ... done
[17:28:19.385] result() for ClusterFuture ...
[17:28:19.385] - result already collected: FutureResult
[17:28:19.385] result() for ClusterFuture ... done
[17:28:19.386] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:28:19.388] plan(): nbrOfWorkers() = 2
[17:28:19.388] getGlobalsAndPackages() ...
[17:28:19.389] Searching for globals...
[17:28:19.390] - globals found: [3] '{', 'sample', 'x'
[17:28:19.390] Searching for globals ... DONE
[17:28:19.391] Resolving globals: FALSE
[17:28:19.391] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:19.392] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:19.392] - globals: [1] 'x'
[17:28:19.392] 
[17:28:19.392] getGlobalsAndPackages() ... DONE
[17:28:19.393] run() for 'Future' ...
[17:28:19.393] - state: 'created'
[17:28:19.393] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:19.407] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:19.408] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:19.408]   - Field: 'node'
[17:28:19.408]   - Field: 'label'
[17:28:19.408]   - Field: 'local'
[17:28:19.408]   - Field: 'owner'
[17:28:19.409]   - Field: 'envir'
[17:28:19.409]   - Field: 'workers'
[17:28:19.409]   - Field: 'packages'
[17:28:19.409]   - Field: 'gc'
[17:28:19.409]   - Field: 'conditions'
[17:28:19.410]   - Field: 'persistent'
[17:28:19.410]   - Field: 'expr'
[17:28:19.410]   - Field: 'uuid'
[17:28:19.410]   - Field: 'seed'
[17:28:19.410]   - Field: 'version'
[17:28:19.411]   - Field: 'result'
[17:28:19.411]   - Field: 'asynchronous'
[17:28:19.411]   - Field: 'calls'
[17:28:19.411]   - Field: 'globals'
[17:28:19.411]   - Field: 'stdout'
[17:28:19.412]   - Field: 'earlySignal'
[17:28:19.412]   - Field: 'lazy'
[17:28:19.412]   - Field: 'state'
[17:28:19.412] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:19.412] - Launch lazy future ...
[17:28:19.413] Packages needed by the future expression (n = 0): <none>
[17:28:19.413] Packages needed by future strategies (n = 0): <none>
[17:28:19.414] {
[17:28:19.414]     {
[17:28:19.414]         {
[17:28:19.414]             ...future.startTime <- base::Sys.time()
[17:28:19.414]             {
[17:28:19.414]                 {
[17:28:19.414]                   {
[17:28:19.414]                     {
[17:28:19.414]                       {
[17:28:19.414]                         base::local({
[17:28:19.414]                           has_future <- base::requireNamespace("future", 
[17:28:19.414]                             quietly = TRUE)
[17:28:19.414]                           if (has_future) {
[17:28:19.414]                             ns <- base::getNamespace("future")
[17:28:19.414]                             version <- ns[[".package"]][["version"]]
[17:28:19.414]                             if (is.null(version)) 
[17:28:19.414]                               version <- utils::packageVersion("future")
[17:28:19.414]                           }
[17:28:19.414]                           else {
[17:28:19.414]                             version <- NULL
[17:28:19.414]                           }
[17:28:19.414]                           if (!has_future || version < "1.8.0") {
[17:28:19.414]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:19.414]                               "", base::R.version$version.string), 
[17:28:19.414]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:19.414]                                 base::R.version$platform, 8 * 
[17:28:19.414]                                   base::.Machine$sizeof.pointer), 
[17:28:19.414]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:19.414]                                 "release", "version")], collapse = " "), 
[17:28:19.414]                               hostname = base::Sys.info()[["nodename"]])
[17:28:19.414]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:19.414]                               info)
[17:28:19.414]                             info <- base::paste(info, collapse = "; ")
[17:28:19.414]                             if (!has_future) {
[17:28:19.414]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:19.414]                                 info)
[17:28:19.414]                             }
[17:28:19.414]                             else {
[17:28:19.414]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:19.414]                                 info, version)
[17:28:19.414]                             }
[17:28:19.414]                             base::stop(msg)
[17:28:19.414]                           }
[17:28:19.414]                         })
[17:28:19.414]                       }
[17:28:19.414]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:19.414]                       base::options(mc.cores = 1L)
[17:28:19.414]                     }
[17:28:19.414]                     ...future.strategy.old <- future::plan("list")
[17:28:19.414]                     options(future.plan = NULL)
[17:28:19.414]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.414]                     future::plan("default", .cleanup = FALSE, 
[17:28:19.414]                       .init = FALSE)
[17:28:19.414]                   }
[17:28:19.414]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:28:19.414]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:28:19.414]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:28:19.414]                 }
[17:28:19.414]                 ...future.workdir <- getwd()
[17:28:19.414]             }
[17:28:19.414]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:19.414]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:19.414]         }
[17:28:19.414]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:19.414]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:19.414]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:19.414]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:19.414]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:19.414]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:19.414]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:19.414]             base::names(...future.oldOptions))
[17:28:19.414]     }
[17:28:19.414]     if (FALSE) {
[17:28:19.414]     }
[17:28:19.414]     else {
[17:28:19.414]         if (TRUE) {
[17:28:19.414]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:19.414]                 open = "w")
[17:28:19.414]         }
[17:28:19.414]         else {
[17:28:19.414]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:19.414]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:19.414]         }
[17:28:19.414]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:19.414]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:19.414]             base::sink(type = "output", split = FALSE)
[17:28:19.414]             base::close(...future.stdout)
[17:28:19.414]         }, add = TRUE)
[17:28:19.414]     }
[17:28:19.414]     ...future.frame <- base::sys.nframe()
[17:28:19.414]     ...future.conditions <- base::list()
[17:28:19.414]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:19.414]     if (FALSE) {
[17:28:19.414]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:19.414]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:19.414]     }
[17:28:19.414]     ...future.result <- base::tryCatch({
[17:28:19.414]         base::withCallingHandlers({
[17:28:19.414]             ...future.value <- base::withVisible(base::local({
[17:28:19.414]                 ...future.makeSendCondition <- base::local({
[17:28:19.414]                   sendCondition <- NULL
[17:28:19.414]                   function(frame = 1L) {
[17:28:19.414]                     if (is.function(sendCondition)) 
[17:28:19.414]                       return(sendCondition)
[17:28:19.414]                     ns <- getNamespace("parallel")
[17:28:19.414]                     if (exists("sendData", mode = "function", 
[17:28:19.414]                       envir = ns)) {
[17:28:19.414]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:19.414]                         envir = ns)
[17:28:19.414]                       envir <- sys.frame(frame)
[17:28:19.414]                       master <- NULL
[17:28:19.414]                       while (!identical(envir, .GlobalEnv) && 
[17:28:19.414]                         !identical(envir, emptyenv())) {
[17:28:19.414]                         if (exists("master", mode = "list", envir = envir, 
[17:28:19.414]                           inherits = FALSE)) {
[17:28:19.414]                           master <- get("master", mode = "list", 
[17:28:19.414]                             envir = envir, inherits = FALSE)
[17:28:19.414]                           if (inherits(master, c("SOCKnode", 
[17:28:19.414]                             "SOCK0node"))) {
[17:28:19.414]                             sendCondition <<- function(cond) {
[17:28:19.414]                               data <- list(type = "VALUE", value = cond, 
[17:28:19.414]                                 success = TRUE)
[17:28:19.414]                               parallel_sendData(master, data)
[17:28:19.414]                             }
[17:28:19.414]                             return(sendCondition)
[17:28:19.414]                           }
[17:28:19.414]                         }
[17:28:19.414]                         frame <- frame + 1L
[17:28:19.414]                         envir <- sys.frame(frame)
[17:28:19.414]                       }
[17:28:19.414]                     }
[17:28:19.414]                     sendCondition <<- function(cond) NULL
[17:28:19.414]                   }
[17:28:19.414]                 })
[17:28:19.414]                 withCallingHandlers({
[17:28:19.414]                   {
[17:28:19.414]                     sample(x, size = 1L)
[17:28:19.414]                   }
[17:28:19.414]                 }, immediateCondition = function(cond) {
[17:28:19.414]                   sendCondition <- ...future.makeSendCondition()
[17:28:19.414]                   sendCondition(cond)
[17:28:19.414]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.414]                   {
[17:28:19.414]                     inherits <- base::inherits
[17:28:19.414]                     invokeRestart <- base::invokeRestart
[17:28:19.414]                     is.null <- base::is.null
[17:28:19.414]                     muffled <- FALSE
[17:28:19.414]                     if (inherits(cond, "message")) {
[17:28:19.414]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:19.414]                       if (muffled) 
[17:28:19.414]                         invokeRestart("muffleMessage")
[17:28:19.414]                     }
[17:28:19.414]                     else if (inherits(cond, "warning")) {
[17:28:19.414]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:19.414]                       if (muffled) 
[17:28:19.414]                         invokeRestart("muffleWarning")
[17:28:19.414]                     }
[17:28:19.414]                     else if (inherits(cond, "condition")) {
[17:28:19.414]                       if (!is.null(pattern)) {
[17:28:19.414]                         computeRestarts <- base::computeRestarts
[17:28:19.414]                         grepl <- base::grepl
[17:28:19.414]                         restarts <- computeRestarts(cond)
[17:28:19.414]                         for (restart in restarts) {
[17:28:19.414]                           name <- restart$name
[17:28:19.414]                           if (is.null(name)) 
[17:28:19.414]                             next
[17:28:19.414]                           if (!grepl(pattern, name)) 
[17:28:19.414]                             next
[17:28:19.414]                           invokeRestart(restart)
[17:28:19.414]                           muffled <- TRUE
[17:28:19.414]                           break
[17:28:19.414]                         }
[17:28:19.414]                       }
[17:28:19.414]                     }
[17:28:19.414]                     invisible(muffled)
[17:28:19.414]                   }
[17:28:19.414]                   muffleCondition(cond)
[17:28:19.414]                 })
[17:28:19.414]             }))
[17:28:19.414]             future::FutureResult(value = ...future.value$value, 
[17:28:19.414]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.414]                   ...future.rng), globalenv = if (FALSE) 
[17:28:19.414]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:19.414]                     ...future.globalenv.names))
[17:28:19.414]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:19.414]         }, condition = base::local({
[17:28:19.414]             c <- base::c
[17:28:19.414]             inherits <- base::inherits
[17:28:19.414]             invokeRestart <- base::invokeRestart
[17:28:19.414]             length <- base::length
[17:28:19.414]             list <- base::list
[17:28:19.414]             seq.int <- base::seq.int
[17:28:19.414]             signalCondition <- base::signalCondition
[17:28:19.414]             sys.calls <- base::sys.calls
[17:28:19.414]             `[[` <- base::`[[`
[17:28:19.414]             `+` <- base::`+`
[17:28:19.414]             `<<-` <- base::`<<-`
[17:28:19.414]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:19.414]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:19.414]                   3L)]
[17:28:19.414]             }
[17:28:19.414]             function(cond) {
[17:28:19.414]                 is_error <- inherits(cond, "error")
[17:28:19.414]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:19.414]                   NULL)
[17:28:19.414]                 if (is_error) {
[17:28:19.414]                   sessionInformation <- function() {
[17:28:19.414]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:19.414]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:19.414]                       search = base::search(), system = base::Sys.info())
[17:28:19.414]                   }
[17:28:19.414]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.414]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:19.414]                     cond$call), session = sessionInformation(), 
[17:28:19.414]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:19.414]                   signalCondition(cond)
[17:28:19.414]                 }
[17:28:19.414]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:19.414]                 "immediateCondition"))) {
[17:28:19.414]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:19.414]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.414]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:19.414]                   if (TRUE && !signal) {
[17:28:19.414]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.414]                     {
[17:28:19.414]                       inherits <- base::inherits
[17:28:19.414]                       invokeRestart <- base::invokeRestart
[17:28:19.414]                       is.null <- base::is.null
[17:28:19.414]                       muffled <- FALSE
[17:28:19.414]                       if (inherits(cond, "message")) {
[17:28:19.414]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.414]                         if (muffled) 
[17:28:19.414]                           invokeRestart("muffleMessage")
[17:28:19.414]                       }
[17:28:19.414]                       else if (inherits(cond, "warning")) {
[17:28:19.414]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.414]                         if (muffled) 
[17:28:19.414]                           invokeRestart("muffleWarning")
[17:28:19.414]                       }
[17:28:19.414]                       else if (inherits(cond, "condition")) {
[17:28:19.414]                         if (!is.null(pattern)) {
[17:28:19.414]                           computeRestarts <- base::computeRestarts
[17:28:19.414]                           grepl <- base::grepl
[17:28:19.414]                           restarts <- computeRestarts(cond)
[17:28:19.414]                           for (restart in restarts) {
[17:28:19.414]                             name <- restart$name
[17:28:19.414]                             if (is.null(name)) 
[17:28:19.414]                               next
[17:28:19.414]                             if (!grepl(pattern, name)) 
[17:28:19.414]                               next
[17:28:19.414]                             invokeRestart(restart)
[17:28:19.414]                             muffled <- TRUE
[17:28:19.414]                             break
[17:28:19.414]                           }
[17:28:19.414]                         }
[17:28:19.414]                       }
[17:28:19.414]                       invisible(muffled)
[17:28:19.414]                     }
[17:28:19.414]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.414]                   }
[17:28:19.414]                 }
[17:28:19.414]                 else {
[17:28:19.414]                   if (TRUE) {
[17:28:19.414]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.414]                     {
[17:28:19.414]                       inherits <- base::inherits
[17:28:19.414]                       invokeRestart <- base::invokeRestart
[17:28:19.414]                       is.null <- base::is.null
[17:28:19.414]                       muffled <- FALSE
[17:28:19.414]                       if (inherits(cond, "message")) {
[17:28:19.414]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.414]                         if (muffled) 
[17:28:19.414]                           invokeRestart("muffleMessage")
[17:28:19.414]                       }
[17:28:19.414]                       else if (inherits(cond, "warning")) {
[17:28:19.414]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.414]                         if (muffled) 
[17:28:19.414]                           invokeRestart("muffleWarning")
[17:28:19.414]                       }
[17:28:19.414]                       else if (inherits(cond, "condition")) {
[17:28:19.414]                         if (!is.null(pattern)) {
[17:28:19.414]                           computeRestarts <- base::computeRestarts
[17:28:19.414]                           grepl <- base::grepl
[17:28:19.414]                           restarts <- computeRestarts(cond)
[17:28:19.414]                           for (restart in restarts) {
[17:28:19.414]                             name <- restart$name
[17:28:19.414]                             if (is.null(name)) 
[17:28:19.414]                               next
[17:28:19.414]                             if (!grepl(pattern, name)) 
[17:28:19.414]                               next
[17:28:19.414]                             invokeRestart(restart)
[17:28:19.414]                             muffled <- TRUE
[17:28:19.414]                             break
[17:28:19.414]                           }
[17:28:19.414]                         }
[17:28:19.414]                       }
[17:28:19.414]                       invisible(muffled)
[17:28:19.414]                     }
[17:28:19.414]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.414]                   }
[17:28:19.414]                 }
[17:28:19.414]             }
[17:28:19.414]         }))
[17:28:19.414]     }, error = function(ex) {
[17:28:19.414]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:19.414]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.414]                 ...future.rng), started = ...future.startTime, 
[17:28:19.414]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:19.414]             version = "1.8"), class = "FutureResult")
[17:28:19.414]     }, finally = {
[17:28:19.414]         if (!identical(...future.workdir, getwd())) 
[17:28:19.414]             setwd(...future.workdir)
[17:28:19.414]         {
[17:28:19.414]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:19.414]                 ...future.oldOptions$nwarnings <- NULL
[17:28:19.414]             }
[17:28:19.414]             base::options(...future.oldOptions)
[17:28:19.414]             if (.Platform$OS.type == "windows") {
[17:28:19.414]                 old_names <- names(...future.oldEnvVars)
[17:28:19.414]                 envs <- base::Sys.getenv()
[17:28:19.414]                 names <- names(envs)
[17:28:19.414]                 common <- intersect(names, old_names)
[17:28:19.414]                 added <- setdiff(names, old_names)
[17:28:19.414]                 removed <- setdiff(old_names, names)
[17:28:19.414]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:19.414]                   envs[common]]
[17:28:19.414]                 NAMES <- toupper(changed)
[17:28:19.414]                 args <- list()
[17:28:19.414]                 for (kk in seq_along(NAMES)) {
[17:28:19.414]                   name <- changed[[kk]]
[17:28:19.414]                   NAME <- NAMES[[kk]]
[17:28:19.414]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.414]                     next
[17:28:19.414]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.414]                 }
[17:28:19.414]                 NAMES <- toupper(added)
[17:28:19.414]                 for (kk in seq_along(NAMES)) {
[17:28:19.414]                   name <- added[[kk]]
[17:28:19.414]                   NAME <- NAMES[[kk]]
[17:28:19.414]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.414]                     next
[17:28:19.414]                   args[[name]] <- ""
[17:28:19.414]                 }
[17:28:19.414]                 NAMES <- toupper(removed)
[17:28:19.414]                 for (kk in seq_along(NAMES)) {
[17:28:19.414]                   name <- removed[[kk]]
[17:28:19.414]                   NAME <- NAMES[[kk]]
[17:28:19.414]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.414]                     next
[17:28:19.414]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.414]                 }
[17:28:19.414]                 if (length(args) > 0) 
[17:28:19.414]                   base::do.call(base::Sys.setenv, args = args)
[17:28:19.414]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:19.414]             }
[17:28:19.414]             else {
[17:28:19.414]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:19.414]             }
[17:28:19.414]             {
[17:28:19.414]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:19.414]                   0L) {
[17:28:19.414]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:19.414]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:19.414]                   base::options(opts)
[17:28:19.414]                 }
[17:28:19.414]                 {
[17:28:19.414]                   {
[17:28:19.414]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:19.414]                     NULL
[17:28:19.414]                   }
[17:28:19.414]                   options(future.plan = NULL)
[17:28:19.414]                   if (is.na(NA_character_)) 
[17:28:19.414]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.414]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:19.414]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:19.414]                     .init = FALSE)
[17:28:19.414]                 }
[17:28:19.414]             }
[17:28:19.414]         }
[17:28:19.414]     })
[17:28:19.414]     if (TRUE) {
[17:28:19.414]         base::sink(type = "output", split = FALSE)
[17:28:19.414]         if (TRUE) {
[17:28:19.414]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:19.414]         }
[17:28:19.414]         else {
[17:28:19.414]             ...future.result["stdout"] <- base::list(NULL)
[17:28:19.414]         }
[17:28:19.414]         base::close(...future.stdout)
[17:28:19.414]         ...future.stdout <- NULL
[17:28:19.414]     }
[17:28:19.414]     ...future.result$conditions <- ...future.conditions
[17:28:19.414]     ...future.result$finished <- base::Sys.time()
[17:28:19.414]     ...future.result
[17:28:19.414] }
[17:28:19.419] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:19.419] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:19.420] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:19.420] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:19.421] MultisessionFuture started
[17:28:19.421] - Launch lazy future ... done
[17:28:19.421] run() for 'MultisessionFuture' ... done
[17:28:19.421] getGlobalsAndPackages() ...
[17:28:19.422] Searching for globals...
[17:28:19.423] - globals found: [3] '{', 'sample', 'x'
[17:28:19.423] Searching for globals ... DONE
[17:28:19.423] Resolving globals: FALSE
[17:28:19.424] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:19.424] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:19.425] - globals: [1] 'x'
[17:28:19.425] 
[17:28:19.425] getGlobalsAndPackages() ... DONE
[17:28:19.425] run() for 'Future' ...
[17:28:19.426] - state: 'created'
[17:28:19.426] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:19.440] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:19.440] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:19.440]   - Field: 'node'
[17:28:19.440]   - Field: 'label'
[17:28:19.441]   - Field: 'local'
[17:28:19.441]   - Field: 'owner'
[17:28:19.441]   - Field: 'envir'
[17:28:19.441]   - Field: 'workers'
[17:28:19.441]   - Field: 'packages'
[17:28:19.442]   - Field: 'gc'
[17:28:19.442]   - Field: 'conditions'
[17:28:19.442]   - Field: 'persistent'
[17:28:19.442]   - Field: 'expr'
[17:28:19.442]   - Field: 'uuid'
[17:28:19.443]   - Field: 'seed'
[17:28:19.443]   - Field: 'version'
[17:28:19.443]   - Field: 'result'
[17:28:19.443]   - Field: 'asynchronous'
[17:28:19.443]   - Field: 'calls'
[17:28:19.444]   - Field: 'globals'
[17:28:19.444]   - Field: 'stdout'
[17:28:19.444]   - Field: 'earlySignal'
[17:28:19.444]   - Field: 'lazy'
[17:28:19.444]   - Field: 'state'
[17:28:19.445] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:19.445] - Launch lazy future ...
[17:28:19.445] Packages needed by the future expression (n = 0): <none>
[17:28:19.445] Packages needed by future strategies (n = 0): <none>
[17:28:19.446] {
[17:28:19.446]     {
[17:28:19.446]         {
[17:28:19.446]             ...future.startTime <- base::Sys.time()
[17:28:19.446]             {
[17:28:19.446]                 {
[17:28:19.446]                   {
[17:28:19.446]                     {
[17:28:19.446]                       {
[17:28:19.446]                         base::local({
[17:28:19.446]                           has_future <- base::requireNamespace("future", 
[17:28:19.446]                             quietly = TRUE)
[17:28:19.446]                           if (has_future) {
[17:28:19.446]                             ns <- base::getNamespace("future")
[17:28:19.446]                             version <- ns[[".package"]][["version"]]
[17:28:19.446]                             if (is.null(version)) 
[17:28:19.446]                               version <- utils::packageVersion("future")
[17:28:19.446]                           }
[17:28:19.446]                           else {
[17:28:19.446]                             version <- NULL
[17:28:19.446]                           }
[17:28:19.446]                           if (!has_future || version < "1.8.0") {
[17:28:19.446]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:19.446]                               "", base::R.version$version.string), 
[17:28:19.446]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:19.446]                                 base::R.version$platform, 8 * 
[17:28:19.446]                                   base::.Machine$sizeof.pointer), 
[17:28:19.446]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:19.446]                                 "release", "version")], collapse = " "), 
[17:28:19.446]                               hostname = base::Sys.info()[["nodename"]])
[17:28:19.446]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:19.446]                               info)
[17:28:19.446]                             info <- base::paste(info, collapse = "; ")
[17:28:19.446]                             if (!has_future) {
[17:28:19.446]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:19.446]                                 info)
[17:28:19.446]                             }
[17:28:19.446]                             else {
[17:28:19.446]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:19.446]                                 info, version)
[17:28:19.446]                             }
[17:28:19.446]                             base::stop(msg)
[17:28:19.446]                           }
[17:28:19.446]                         })
[17:28:19.446]                       }
[17:28:19.446]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:19.446]                       base::options(mc.cores = 1L)
[17:28:19.446]                     }
[17:28:19.446]                     ...future.strategy.old <- future::plan("list")
[17:28:19.446]                     options(future.plan = NULL)
[17:28:19.446]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.446]                     future::plan("default", .cleanup = FALSE, 
[17:28:19.446]                       .init = FALSE)
[17:28:19.446]                   }
[17:28:19.446]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:28:19.446]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:28:19.446]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:28:19.446]                 }
[17:28:19.446]                 ...future.workdir <- getwd()
[17:28:19.446]             }
[17:28:19.446]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:19.446]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:19.446]         }
[17:28:19.446]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:19.446]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:19.446]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:19.446]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:19.446]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:19.446]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:19.446]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:19.446]             base::names(...future.oldOptions))
[17:28:19.446]     }
[17:28:19.446]     if (FALSE) {
[17:28:19.446]     }
[17:28:19.446]     else {
[17:28:19.446]         if (TRUE) {
[17:28:19.446]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:19.446]                 open = "w")
[17:28:19.446]         }
[17:28:19.446]         else {
[17:28:19.446]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:19.446]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:19.446]         }
[17:28:19.446]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:19.446]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:19.446]             base::sink(type = "output", split = FALSE)
[17:28:19.446]             base::close(...future.stdout)
[17:28:19.446]         }, add = TRUE)
[17:28:19.446]     }
[17:28:19.446]     ...future.frame <- base::sys.nframe()
[17:28:19.446]     ...future.conditions <- base::list()
[17:28:19.446]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:19.446]     if (FALSE) {
[17:28:19.446]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:19.446]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:19.446]     }
[17:28:19.446]     ...future.result <- base::tryCatch({
[17:28:19.446]         base::withCallingHandlers({
[17:28:19.446]             ...future.value <- base::withVisible(base::local({
[17:28:19.446]                 ...future.makeSendCondition <- base::local({
[17:28:19.446]                   sendCondition <- NULL
[17:28:19.446]                   function(frame = 1L) {
[17:28:19.446]                     if (is.function(sendCondition)) 
[17:28:19.446]                       return(sendCondition)
[17:28:19.446]                     ns <- getNamespace("parallel")
[17:28:19.446]                     if (exists("sendData", mode = "function", 
[17:28:19.446]                       envir = ns)) {
[17:28:19.446]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:19.446]                         envir = ns)
[17:28:19.446]                       envir <- sys.frame(frame)
[17:28:19.446]                       master <- NULL
[17:28:19.446]                       while (!identical(envir, .GlobalEnv) && 
[17:28:19.446]                         !identical(envir, emptyenv())) {
[17:28:19.446]                         if (exists("master", mode = "list", envir = envir, 
[17:28:19.446]                           inherits = FALSE)) {
[17:28:19.446]                           master <- get("master", mode = "list", 
[17:28:19.446]                             envir = envir, inherits = FALSE)
[17:28:19.446]                           if (inherits(master, c("SOCKnode", 
[17:28:19.446]                             "SOCK0node"))) {
[17:28:19.446]                             sendCondition <<- function(cond) {
[17:28:19.446]                               data <- list(type = "VALUE", value = cond, 
[17:28:19.446]                                 success = TRUE)
[17:28:19.446]                               parallel_sendData(master, data)
[17:28:19.446]                             }
[17:28:19.446]                             return(sendCondition)
[17:28:19.446]                           }
[17:28:19.446]                         }
[17:28:19.446]                         frame <- frame + 1L
[17:28:19.446]                         envir <- sys.frame(frame)
[17:28:19.446]                       }
[17:28:19.446]                     }
[17:28:19.446]                     sendCondition <<- function(cond) NULL
[17:28:19.446]                   }
[17:28:19.446]                 })
[17:28:19.446]                 withCallingHandlers({
[17:28:19.446]                   {
[17:28:19.446]                     sample(x, size = 1L)
[17:28:19.446]                   }
[17:28:19.446]                 }, immediateCondition = function(cond) {
[17:28:19.446]                   sendCondition <- ...future.makeSendCondition()
[17:28:19.446]                   sendCondition(cond)
[17:28:19.446]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.446]                   {
[17:28:19.446]                     inherits <- base::inherits
[17:28:19.446]                     invokeRestart <- base::invokeRestart
[17:28:19.446]                     is.null <- base::is.null
[17:28:19.446]                     muffled <- FALSE
[17:28:19.446]                     if (inherits(cond, "message")) {
[17:28:19.446]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:19.446]                       if (muffled) 
[17:28:19.446]                         invokeRestart("muffleMessage")
[17:28:19.446]                     }
[17:28:19.446]                     else if (inherits(cond, "warning")) {
[17:28:19.446]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:19.446]                       if (muffled) 
[17:28:19.446]                         invokeRestart("muffleWarning")
[17:28:19.446]                     }
[17:28:19.446]                     else if (inherits(cond, "condition")) {
[17:28:19.446]                       if (!is.null(pattern)) {
[17:28:19.446]                         computeRestarts <- base::computeRestarts
[17:28:19.446]                         grepl <- base::grepl
[17:28:19.446]                         restarts <- computeRestarts(cond)
[17:28:19.446]                         for (restart in restarts) {
[17:28:19.446]                           name <- restart$name
[17:28:19.446]                           if (is.null(name)) 
[17:28:19.446]                             next
[17:28:19.446]                           if (!grepl(pattern, name)) 
[17:28:19.446]                             next
[17:28:19.446]                           invokeRestart(restart)
[17:28:19.446]                           muffled <- TRUE
[17:28:19.446]                           break
[17:28:19.446]                         }
[17:28:19.446]                       }
[17:28:19.446]                     }
[17:28:19.446]                     invisible(muffled)
[17:28:19.446]                   }
[17:28:19.446]                   muffleCondition(cond)
[17:28:19.446]                 })
[17:28:19.446]             }))
[17:28:19.446]             future::FutureResult(value = ...future.value$value, 
[17:28:19.446]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.446]                   ...future.rng), globalenv = if (FALSE) 
[17:28:19.446]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:19.446]                     ...future.globalenv.names))
[17:28:19.446]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:19.446]         }, condition = base::local({
[17:28:19.446]             c <- base::c
[17:28:19.446]             inherits <- base::inherits
[17:28:19.446]             invokeRestart <- base::invokeRestart
[17:28:19.446]             length <- base::length
[17:28:19.446]             list <- base::list
[17:28:19.446]             seq.int <- base::seq.int
[17:28:19.446]             signalCondition <- base::signalCondition
[17:28:19.446]             sys.calls <- base::sys.calls
[17:28:19.446]             `[[` <- base::`[[`
[17:28:19.446]             `+` <- base::`+`
[17:28:19.446]             `<<-` <- base::`<<-`
[17:28:19.446]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:19.446]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:19.446]                   3L)]
[17:28:19.446]             }
[17:28:19.446]             function(cond) {
[17:28:19.446]                 is_error <- inherits(cond, "error")
[17:28:19.446]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:19.446]                   NULL)
[17:28:19.446]                 if (is_error) {
[17:28:19.446]                   sessionInformation <- function() {
[17:28:19.446]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:19.446]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:19.446]                       search = base::search(), system = base::Sys.info())
[17:28:19.446]                   }
[17:28:19.446]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.446]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:19.446]                     cond$call), session = sessionInformation(), 
[17:28:19.446]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:19.446]                   signalCondition(cond)
[17:28:19.446]                 }
[17:28:19.446]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:19.446]                 "immediateCondition"))) {
[17:28:19.446]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:19.446]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.446]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:19.446]                   if (TRUE && !signal) {
[17:28:19.446]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.446]                     {
[17:28:19.446]                       inherits <- base::inherits
[17:28:19.446]                       invokeRestart <- base::invokeRestart
[17:28:19.446]                       is.null <- base::is.null
[17:28:19.446]                       muffled <- FALSE
[17:28:19.446]                       if (inherits(cond, "message")) {
[17:28:19.446]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.446]                         if (muffled) 
[17:28:19.446]                           invokeRestart("muffleMessage")
[17:28:19.446]                       }
[17:28:19.446]                       else if (inherits(cond, "warning")) {
[17:28:19.446]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.446]                         if (muffled) 
[17:28:19.446]                           invokeRestart("muffleWarning")
[17:28:19.446]                       }
[17:28:19.446]                       else if (inherits(cond, "condition")) {
[17:28:19.446]                         if (!is.null(pattern)) {
[17:28:19.446]                           computeRestarts <- base::computeRestarts
[17:28:19.446]                           grepl <- base::grepl
[17:28:19.446]                           restarts <- computeRestarts(cond)
[17:28:19.446]                           for (restart in restarts) {
[17:28:19.446]                             name <- restart$name
[17:28:19.446]                             if (is.null(name)) 
[17:28:19.446]                               next
[17:28:19.446]                             if (!grepl(pattern, name)) 
[17:28:19.446]                               next
[17:28:19.446]                             invokeRestart(restart)
[17:28:19.446]                             muffled <- TRUE
[17:28:19.446]                             break
[17:28:19.446]                           }
[17:28:19.446]                         }
[17:28:19.446]                       }
[17:28:19.446]                       invisible(muffled)
[17:28:19.446]                     }
[17:28:19.446]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.446]                   }
[17:28:19.446]                 }
[17:28:19.446]                 else {
[17:28:19.446]                   if (TRUE) {
[17:28:19.446]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.446]                     {
[17:28:19.446]                       inherits <- base::inherits
[17:28:19.446]                       invokeRestart <- base::invokeRestart
[17:28:19.446]                       is.null <- base::is.null
[17:28:19.446]                       muffled <- FALSE
[17:28:19.446]                       if (inherits(cond, "message")) {
[17:28:19.446]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.446]                         if (muffled) 
[17:28:19.446]                           invokeRestart("muffleMessage")
[17:28:19.446]                       }
[17:28:19.446]                       else if (inherits(cond, "warning")) {
[17:28:19.446]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.446]                         if (muffled) 
[17:28:19.446]                           invokeRestart("muffleWarning")
[17:28:19.446]                       }
[17:28:19.446]                       else if (inherits(cond, "condition")) {
[17:28:19.446]                         if (!is.null(pattern)) {
[17:28:19.446]                           computeRestarts <- base::computeRestarts
[17:28:19.446]                           grepl <- base::grepl
[17:28:19.446]                           restarts <- computeRestarts(cond)
[17:28:19.446]                           for (restart in restarts) {
[17:28:19.446]                             name <- restart$name
[17:28:19.446]                             if (is.null(name)) 
[17:28:19.446]                               next
[17:28:19.446]                             if (!grepl(pattern, name)) 
[17:28:19.446]                               next
[17:28:19.446]                             invokeRestart(restart)
[17:28:19.446]                             muffled <- TRUE
[17:28:19.446]                             break
[17:28:19.446]                           }
[17:28:19.446]                         }
[17:28:19.446]                       }
[17:28:19.446]                       invisible(muffled)
[17:28:19.446]                     }
[17:28:19.446]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.446]                   }
[17:28:19.446]                 }
[17:28:19.446]             }
[17:28:19.446]         }))
[17:28:19.446]     }, error = function(ex) {
[17:28:19.446]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:19.446]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.446]                 ...future.rng), started = ...future.startTime, 
[17:28:19.446]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:19.446]             version = "1.8"), class = "FutureResult")
[17:28:19.446]     }, finally = {
[17:28:19.446]         if (!identical(...future.workdir, getwd())) 
[17:28:19.446]             setwd(...future.workdir)
[17:28:19.446]         {
[17:28:19.446]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:19.446]                 ...future.oldOptions$nwarnings <- NULL
[17:28:19.446]             }
[17:28:19.446]             base::options(...future.oldOptions)
[17:28:19.446]             if (.Platform$OS.type == "windows") {
[17:28:19.446]                 old_names <- names(...future.oldEnvVars)
[17:28:19.446]                 envs <- base::Sys.getenv()
[17:28:19.446]                 names <- names(envs)
[17:28:19.446]                 common <- intersect(names, old_names)
[17:28:19.446]                 added <- setdiff(names, old_names)
[17:28:19.446]                 removed <- setdiff(old_names, names)
[17:28:19.446]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:19.446]                   envs[common]]
[17:28:19.446]                 NAMES <- toupper(changed)
[17:28:19.446]                 args <- list()
[17:28:19.446]                 for (kk in seq_along(NAMES)) {
[17:28:19.446]                   name <- changed[[kk]]
[17:28:19.446]                   NAME <- NAMES[[kk]]
[17:28:19.446]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.446]                     next
[17:28:19.446]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.446]                 }
[17:28:19.446]                 NAMES <- toupper(added)
[17:28:19.446]                 for (kk in seq_along(NAMES)) {
[17:28:19.446]                   name <- added[[kk]]
[17:28:19.446]                   NAME <- NAMES[[kk]]
[17:28:19.446]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.446]                     next
[17:28:19.446]                   args[[name]] <- ""
[17:28:19.446]                 }
[17:28:19.446]                 NAMES <- toupper(removed)
[17:28:19.446]                 for (kk in seq_along(NAMES)) {
[17:28:19.446]                   name <- removed[[kk]]
[17:28:19.446]                   NAME <- NAMES[[kk]]
[17:28:19.446]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.446]                     next
[17:28:19.446]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.446]                 }
[17:28:19.446]                 if (length(args) > 0) 
[17:28:19.446]                   base::do.call(base::Sys.setenv, args = args)
[17:28:19.446]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:19.446]             }
[17:28:19.446]             else {
[17:28:19.446]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:19.446]             }
[17:28:19.446]             {
[17:28:19.446]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:19.446]                   0L) {
[17:28:19.446]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:19.446]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:19.446]                   base::options(opts)
[17:28:19.446]                 }
[17:28:19.446]                 {
[17:28:19.446]                   {
[17:28:19.446]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:19.446]                     NULL
[17:28:19.446]                   }
[17:28:19.446]                   options(future.plan = NULL)
[17:28:19.446]                   if (is.na(NA_character_)) 
[17:28:19.446]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.446]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:19.446]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:19.446]                     .init = FALSE)
[17:28:19.446]                 }
[17:28:19.446]             }
[17:28:19.446]         }
[17:28:19.446]     })
[17:28:19.446]     if (TRUE) {
[17:28:19.446]         base::sink(type = "output", split = FALSE)
[17:28:19.446]         if (TRUE) {
[17:28:19.446]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:19.446]         }
[17:28:19.446]         else {
[17:28:19.446]             ...future.result["stdout"] <- base::list(NULL)
[17:28:19.446]         }
[17:28:19.446]         base::close(...future.stdout)
[17:28:19.446]         ...future.stdout <- NULL
[17:28:19.446]     }
[17:28:19.446]     ...future.result$conditions <- ...future.conditions
[17:28:19.446]     ...future.result$finished <- base::Sys.time()
[17:28:19.446]     ...future.result
[17:28:19.446] }
[17:28:19.527] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:19.528] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:19.528] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:19.528] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:19.529] MultisessionFuture started
[17:28:19.529] - Launch lazy future ... done
[17:28:19.530] run() for 'MultisessionFuture' ... done
[17:28:19.530] getGlobalsAndPackages() ...
[17:28:19.530] Searching for globals...
[17:28:19.531] - globals found: [3] '{', 'sample', 'x'
[17:28:19.532] Searching for globals ... DONE
[17:28:19.532] Resolving globals: FALSE
[17:28:19.532] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:19.533] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:19.533] - globals: [1] 'x'
[17:28:19.533] 
[17:28:19.533] getGlobalsAndPackages() ... DONE
[17:28:19.534] run() for 'Future' ...
[17:28:19.534] - state: 'created'
[17:28:19.534] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:19.549] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:19.549] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:19.549]   - Field: 'node'
[17:28:19.550]   - Field: 'label'
[17:28:19.550]   - Field: 'local'
[17:28:19.550]   - Field: 'owner'
[17:28:19.550]   - Field: 'envir'
[17:28:19.550]   - Field: 'workers'
[17:28:19.551]   - Field: 'packages'
[17:28:19.551]   - Field: 'gc'
[17:28:19.551]   - Field: 'conditions'
[17:28:19.551]   - Field: 'persistent'
[17:28:19.551]   - Field: 'expr'
[17:28:19.552]   - Field: 'uuid'
[17:28:19.552]   - Field: 'seed'
[17:28:19.552]   - Field: 'version'
[17:28:19.552]   - Field: 'result'
[17:28:19.552]   - Field: 'asynchronous'
[17:28:19.553]   - Field: 'calls'
[17:28:19.553]   - Field: 'globals'
[17:28:19.553]   - Field: 'stdout'
[17:28:19.553]   - Field: 'earlySignal'
[17:28:19.553]   - Field: 'lazy'
[17:28:19.554]   - Field: 'state'
[17:28:19.554] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:19.554] - Launch lazy future ...
[17:28:19.554] Packages needed by the future expression (n = 0): <none>
[17:28:19.555] Packages needed by future strategies (n = 0): <none>
[17:28:19.555] {
[17:28:19.555]     {
[17:28:19.555]         {
[17:28:19.555]             ...future.startTime <- base::Sys.time()
[17:28:19.555]             {
[17:28:19.555]                 {
[17:28:19.555]                   {
[17:28:19.555]                     {
[17:28:19.555]                       {
[17:28:19.555]                         base::local({
[17:28:19.555]                           has_future <- base::requireNamespace("future", 
[17:28:19.555]                             quietly = TRUE)
[17:28:19.555]                           if (has_future) {
[17:28:19.555]                             ns <- base::getNamespace("future")
[17:28:19.555]                             version <- ns[[".package"]][["version"]]
[17:28:19.555]                             if (is.null(version)) 
[17:28:19.555]                               version <- utils::packageVersion("future")
[17:28:19.555]                           }
[17:28:19.555]                           else {
[17:28:19.555]                             version <- NULL
[17:28:19.555]                           }
[17:28:19.555]                           if (!has_future || version < "1.8.0") {
[17:28:19.555]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:19.555]                               "", base::R.version$version.string), 
[17:28:19.555]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:19.555]                                 base::R.version$platform, 8 * 
[17:28:19.555]                                   base::.Machine$sizeof.pointer), 
[17:28:19.555]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:19.555]                                 "release", "version")], collapse = " "), 
[17:28:19.555]                               hostname = base::Sys.info()[["nodename"]])
[17:28:19.555]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:19.555]                               info)
[17:28:19.555]                             info <- base::paste(info, collapse = "; ")
[17:28:19.555]                             if (!has_future) {
[17:28:19.555]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:19.555]                                 info)
[17:28:19.555]                             }
[17:28:19.555]                             else {
[17:28:19.555]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:19.555]                                 info, version)
[17:28:19.555]                             }
[17:28:19.555]                             base::stop(msg)
[17:28:19.555]                           }
[17:28:19.555]                         })
[17:28:19.555]                       }
[17:28:19.555]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:19.555]                       base::options(mc.cores = 1L)
[17:28:19.555]                     }
[17:28:19.555]                     ...future.strategy.old <- future::plan("list")
[17:28:19.555]                     options(future.plan = NULL)
[17:28:19.555]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.555]                     future::plan("default", .cleanup = FALSE, 
[17:28:19.555]                       .init = FALSE)
[17:28:19.555]                   }
[17:28:19.555]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:28:19.555]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:28:19.555]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:28:19.555]                 }
[17:28:19.555]                 ...future.workdir <- getwd()
[17:28:19.555]             }
[17:28:19.555]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:19.555]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:19.555]         }
[17:28:19.555]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:19.555]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:19.555]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:19.555]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:19.555]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:19.555]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:19.555]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:19.555]             base::names(...future.oldOptions))
[17:28:19.555]     }
[17:28:19.555]     if (FALSE) {
[17:28:19.555]     }
[17:28:19.555]     else {
[17:28:19.555]         if (TRUE) {
[17:28:19.555]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:19.555]                 open = "w")
[17:28:19.555]         }
[17:28:19.555]         else {
[17:28:19.555]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:19.555]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:19.555]         }
[17:28:19.555]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:19.555]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:19.555]             base::sink(type = "output", split = FALSE)
[17:28:19.555]             base::close(...future.stdout)
[17:28:19.555]         }, add = TRUE)
[17:28:19.555]     }
[17:28:19.555]     ...future.frame <- base::sys.nframe()
[17:28:19.555]     ...future.conditions <- base::list()
[17:28:19.555]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:19.555]     if (FALSE) {
[17:28:19.555]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:19.555]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:19.555]     }
[17:28:19.555]     ...future.result <- base::tryCatch({
[17:28:19.555]         base::withCallingHandlers({
[17:28:19.555]             ...future.value <- base::withVisible(base::local({
[17:28:19.555]                 ...future.makeSendCondition <- base::local({
[17:28:19.555]                   sendCondition <- NULL
[17:28:19.555]                   function(frame = 1L) {
[17:28:19.555]                     if (is.function(sendCondition)) 
[17:28:19.555]                       return(sendCondition)
[17:28:19.555]                     ns <- getNamespace("parallel")
[17:28:19.555]                     if (exists("sendData", mode = "function", 
[17:28:19.555]                       envir = ns)) {
[17:28:19.555]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:19.555]                         envir = ns)
[17:28:19.555]                       envir <- sys.frame(frame)
[17:28:19.555]                       master <- NULL
[17:28:19.555]                       while (!identical(envir, .GlobalEnv) && 
[17:28:19.555]                         !identical(envir, emptyenv())) {
[17:28:19.555]                         if (exists("master", mode = "list", envir = envir, 
[17:28:19.555]                           inherits = FALSE)) {
[17:28:19.555]                           master <- get("master", mode = "list", 
[17:28:19.555]                             envir = envir, inherits = FALSE)
[17:28:19.555]                           if (inherits(master, c("SOCKnode", 
[17:28:19.555]                             "SOCK0node"))) {
[17:28:19.555]                             sendCondition <<- function(cond) {
[17:28:19.555]                               data <- list(type = "VALUE", value = cond, 
[17:28:19.555]                                 success = TRUE)
[17:28:19.555]                               parallel_sendData(master, data)
[17:28:19.555]                             }
[17:28:19.555]                             return(sendCondition)
[17:28:19.555]                           }
[17:28:19.555]                         }
[17:28:19.555]                         frame <- frame + 1L
[17:28:19.555]                         envir <- sys.frame(frame)
[17:28:19.555]                       }
[17:28:19.555]                     }
[17:28:19.555]                     sendCondition <<- function(cond) NULL
[17:28:19.555]                   }
[17:28:19.555]                 })
[17:28:19.555]                 withCallingHandlers({
[17:28:19.555]                   {
[17:28:19.555]                     sample(x, size = 1L)
[17:28:19.555]                   }
[17:28:19.555]                 }, immediateCondition = function(cond) {
[17:28:19.555]                   sendCondition <- ...future.makeSendCondition()
[17:28:19.555]                   sendCondition(cond)
[17:28:19.555]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.555]                   {
[17:28:19.555]                     inherits <- base::inherits
[17:28:19.555]                     invokeRestart <- base::invokeRestart
[17:28:19.555]                     is.null <- base::is.null
[17:28:19.555]                     muffled <- FALSE
[17:28:19.555]                     if (inherits(cond, "message")) {
[17:28:19.555]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:19.555]                       if (muffled) 
[17:28:19.555]                         invokeRestart("muffleMessage")
[17:28:19.555]                     }
[17:28:19.555]                     else if (inherits(cond, "warning")) {
[17:28:19.555]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:19.555]                       if (muffled) 
[17:28:19.555]                         invokeRestart("muffleWarning")
[17:28:19.555]                     }
[17:28:19.555]                     else if (inherits(cond, "condition")) {
[17:28:19.555]                       if (!is.null(pattern)) {
[17:28:19.555]                         computeRestarts <- base::computeRestarts
[17:28:19.555]                         grepl <- base::grepl
[17:28:19.555]                         restarts <- computeRestarts(cond)
[17:28:19.555]                         for (restart in restarts) {
[17:28:19.555]                           name <- restart$name
[17:28:19.555]                           if (is.null(name)) 
[17:28:19.555]                             next
[17:28:19.555]                           if (!grepl(pattern, name)) 
[17:28:19.555]                             next
[17:28:19.555]                           invokeRestart(restart)
[17:28:19.555]                           muffled <- TRUE
[17:28:19.555]                           break
[17:28:19.555]                         }
[17:28:19.555]                       }
[17:28:19.555]                     }
[17:28:19.555]                     invisible(muffled)
[17:28:19.555]                   }
[17:28:19.555]                   muffleCondition(cond)
[17:28:19.555]                 })
[17:28:19.555]             }))
[17:28:19.555]             future::FutureResult(value = ...future.value$value, 
[17:28:19.555]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.555]                   ...future.rng), globalenv = if (FALSE) 
[17:28:19.555]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:19.555]                     ...future.globalenv.names))
[17:28:19.555]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:19.555]         }, condition = base::local({
[17:28:19.555]             c <- base::c
[17:28:19.555]             inherits <- base::inherits
[17:28:19.555]             invokeRestart <- base::invokeRestart
[17:28:19.555]             length <- base::length
[17:28:19.555]             list <- base::list
[17:28:19.555]             seq.int <- base::seq.int
[17:28:19.555]             signalCondition <- base::signalCondition
[17:28:19.555]             sys.calls <- base::sys.calls
[17:28:19.555]             `[[` <- base::`[[`
[17:28:19.555]             `+` <- base::`+`
[17:28:19.555]             `<<-` <- base::`<<-`
[17:28:19.555]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:19.555]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:19.555]                   3L)]
[17:28:19.555]             }
[17:28:19.555]             function(cond) {
[17:28:19.555]                 is_error <- inherits(cond, "error")
[17:28:19.555]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:19.555]                   NULL)
[17:28:19.555]                 if (is_error) {
[17:28:19.555]                   sessionInformation <- function() {
[17:28:19.555]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:19.555]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:19.555]                       search = base::search(), system = base::Sys.info())
[17:28:19.555]                   }
[17:28:19.555]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.555]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:19.555]                     cond$call), session = sessionInformation(), 
[17:28:19.555]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:19.555]                   signalCondition(cond)
[17:28:19.555]                 }
[17:28:19.555]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:19.555]                 "immediateCondition"))) {
[17:28:19.555]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:19.555]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.555]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:19.555]                   if (TRUE && !signal) {
[17:28:19.555]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.555]                     {
[17:28:19.555]                       inherits <- base::inherits
[17:28:19.555]                       invokeRestart <- base::invokeRestart
[17:28:19.555]                       is.null <- base::is.null
[17:28:19.555]                       muffled <- FALSE
[17:28:19.555]                       if (inherits(cond, "message")) {
[17:28:19.555]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.555]                         if (muffled) 
[17:28:19.555]                           invokeRestart("muffleMessage")
[17:28:19.555]                       }
[17:28:19.555]                       else if (inherits(cond, "warning")) {
[17:28:19.555]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.555]                         if (muffled) 
[17:28:19.555]                           invokeRestart("muffleWarning")
[17:28:19.555]                       }
[17:28:19.555]                       else if (inherits(cond, "condition")) {
[17:28:19.555]                         if (!is.null(pattern)) {
[17:28:19.555]                           computeRestarts <- base::computeRestarts
[17:28:19.555]                           grepl <- base::grepl
[17:28:19.555]                           restarts <- computeRestarts(cond)
[17:28:19.555]                           for (restart in restarts) {
[17:28:19.555]                             name <- restart$name
[17:28:19.555]                             if (is.null(name)) 
[17:28:19.555]                               next
[17:28:19.555]                             if (!grepl(pattern, name)) 
[17:28:19.555]                               next
[17:28:19.555]                             invokeRestart(restart)
[17:28:19.555]                             muffled <- TRUE
[17:28:19.555]                             break
[17:28:19.555]                           }
[17:28:19.555]                         }
[17:28:19.555]                       }
[17:28:19.555]                       invisible(muffled)
[17:28:19.555]                     }
[17:28:19.555]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.555]                   }
[17:28:19.555]                 }
[17:28:19.555]                 else {
[17:28:19.555]                   if (TRUE) {
[17:28:19.555]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.555]                     {
[17:28:19.555]                       inherits <- base::inherits
[17:28:19.555]                       invokeRestart <- base::invokeRestart
[17:28:19.555]                       is.null <- base::is.null
[17:28:19.555]                       muffled <- FALSE
[17:28:19.555]                       if (inherits(cond, "message")) {
[17:28:19.555]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.555]                         if (muffled) 
[17:28:19.555]                           invokeRestart("muffleMessage")
[17:28:19.555]                       }
[17:28:19.555]                       else if (inherits(cond, "warning")) {
[17:28:19.555]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.555]                         if (muffled) 
[17:28:19.555]                           invokeRestart("muffleWarning")
[17:28:19.555]                       }
[17:28:19.555]                       else if (inherits(cond, "condition")) {
[17:28:19.555]                         if (!is.null(pattern)) {
[17:28:19.555]                           computeRestarts <- base::computeRestarts
[17:28:19.555]                           grepl <- base::grepl
[17:28:19.555]                           restarts <- computeRestarts(cond)
[17:28:19.555]                           for (restart in restarts) {
[17:28:19.555]                             name <- restart$name
[17:28:19.555]                             if (is.null(name)) 
[17:28:19.555]                               next
[17:28:19.555]                             if (!grepl(pattern, name)) 
[17:28:19.555]                               next
[17:28:19.555]                             invokeRestart(restart)
[17:28:19.555]                             muffled <- TRUE
[17:28:19.555]                             break
[17:28:19.555]                           }
[17:28:19.555]                         }
[17:28:19.555]                       }
[17:28:19.555]                       invisible(muffled)
[17:28:19.555]                     }
[17:28:19.555]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.555]                   }
[17:28:19.555]                 }
[17:28:19.555]             }
[17:28:19.555]         }))
[17:28:19.555]     }, error = function(ex) {
[17:28:19.555]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:19.555]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.555]                 ...future.rng), started = ...future.startTime, 
[17:28:19.555]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:19.555]             version = "1.8"), class = "FutureResult")
[17:28:19.555]     }, finally = {
[17:28:19.555]         if (!identical(...future.workdir, getwd())) 
[17:28:19.555]             setwd(...future.workdir)
[17:28:19.555]         {
[17:28:19.555]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:19.555]                 ...future.oldOptions$nwarnings <- NULL
[17:28:19.555]             }
[17:28:19.555]             base::options(...future.oldOptions)
[17:28:19.555]             if (.Platform$OS.type == "windows") {
[17:28:19.555]                 old_names <- names(...future.oldEnvVars)
[17:28:19.555]                 envs <- base::Sys.getenv()
[17:28:19.555]                 names <- names(envs)
[17:28:19.555]                 common <- intersect(names, old_names)
[17:28:19.555]                 added <- setdiff(names, old_names)
[17:28:19.555]                 removed <- setdiff(old_names, names)
[17:28:19.555]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:19.555]                   envs[common]]
[17:28:19.555]                 NAMES <- toupper(changed)
[17:28:19.555]                 args <- list()
[17:28:19.555]                 for (kk in seq_along(NAMES)) {
[17:28:19.555]                   name <- changed[[kk]]
[17:28:19.555]                   NAME <- NAMES[[kk]]
[17:28:19.555]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.555]                     next
[17:28:19.555]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.555]                 }
[17:28:19.555]                 NAMES <- toupper(added)
[17:28:19.555]                 for (kk in seq_along(NAMES)) {
[17:28:19.555]                   name <- added[[kk]]
[17:28:19.555]                   NAME <- NAMES[[kk]]
[17:28:19.555]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.555]                     next
[17:28:19.555]                   args[[name]] <- ""
[17:28:19.555]                 }
[17:28:19.555]                 NAMES <- toupper(removed)
[17:28:19.555]                 for (kk in seq_along(NAMES)) {
[17:28:19.555]                   name <- removed[[kk]]
[17:28:19.555]                   NAME <- NAMES[[kk]]
[17:28:19.555]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.555]                     next
[17:28:19.555]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.555]                 }
[17:28:19.555]                 if (length(args) > 0) 
[17:28:19.555]                   base::do.call(base::Sys.setenv, args = args)
[17:28:19.555]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:19.555]             }
[17:28:19.555]             else {
[17:28:19.555]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:19.555]             }
[17:28:19.555]             {
[17:28:19.555]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:19.555]                   0L) {
[17:28:19.555]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:19.555]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:19.555]                   base::options(opts)
[17:28:19.555]                 }
[17:28:19.555]                 {
[17:28:19.555]                   {
[17:28:19.555]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:19.555]                     NULL
[17:28:19.555]                   }
[17:28:19.555]                   options(future.plan = NULL)
[17:28:19.555]                   if (is.na(NA_character_)) 
[17:28:19.555]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.555]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:19.555]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:19.555]                     .init = FALSE)
[17:28:19.555]                 }
[17:28:19.555]             }
[17:28:19.555]         }
[17:28:19.555]     })
[17:28:19.555]     if (TRUE) {
[17:28:19.555]         base::sink(type = "output", split = FALSE)
[17:28:19.555]         if (TRUE) {
[17:28:19.555]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:19.555]         }
[17:28:19.555]         else {
[17:28:19.555]             ...future.result["stdout"] <- base::list(NULL)
[17:28:19.555]         }
[17:28:19.555]         base::close(...future.stdout)
[17:28:19.555]         ...future.stdout <- NULL
[17:28:19.555]     }
[17:28:19.555]     ...future.result$conditions <- ...future.conditions
[17:28:19.555]     ...future.result$finished <- base::Sys.time()
[17:28:19.555]     ...future.result
[17:28:19.555] }
[17:28:19.560] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:19.578] receiveMessageFromWorker() for ClusterFuture ...
[17:28:19.578] - Validating connection of MultisessionFuture
[17:28:19.578] - received message: FutureResult
[17:28:19.578] - Received FutureResult
[17:28:19.579] - Erased future from FutureRegistry
[17:28:19.579] result() for ClusterFuture ...
[17:28:19.579] - result already collected: FutureResult
[17:28:19.579] result() for ClusterFuture ... done
[17:28:19.579] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:19.580] result() for ClusterFuture ...
[17:28:19.580] - result already collected: FutureResult
[17:28:19.580] result() for ClusterFuture ... done
[17:28:19.580] result() for ClusterFuture ...
[17:28:19.580] - result already collected: FutureResult
[17:28:19.581] result() for ClusterFuture ... done
[17:28:19.582] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:19.582] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:19.582] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:19.583] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:19.583] MultisessionFuture started
[17:28:19.583] - Launch lazy future ... done
[17:28:19.584] run() for 'MultisessionFuture' ... done
[17:28:19.584] getGlobalsAndPackages() ...
[17:28:19.584] Searching for globals...
[17:28:19.585] - globals found: [3] '{', 'sample', 'x'
[17:28:19.586] Searching for globals ... DONE
[17:28:19.586] Resolving globals: FALSE
[17:28:19.586] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:19.587] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:19.587] - globals: [1] 'x'
[17:28:19.587] 
[17:28:19.587] getGlobalsAndPackages() ... DONE
[17:28:19.588] run() for 'Future' ...
[17:28:19.588] - state: 'created'
[17:28:19.588] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:19.604] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:19.604] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:19.605]   - Field: 'node'
[17:28:19.605]   - Field: 'label'
[17:28:19.605]   - Field: 'local'
[17:28:19.605]   - Field: 'owner'
[17:28:19.605]   - Field: 'envir'
[17:28:19.606]   - Field: 'workers'
[17:28:19.606]   - Field: 'packages'
[17:28:19.606]   - Field: 'gc'
[17:28:19.606]   - Field: 'conditions'
[17:28:19.606]   - Field: 'persistent'
[17:28:19.606]   - Field: 'expr'
[17:28:19.607]   - Field: 'uuid'
[17:28:19.607]   - Field: 'seed'
[17:28:19.607]   - Field: 'version'
[17:28:19.607]   - Field: 'result'
[17:28:19.607]   - Field: 'asynchronous'
[17:28:19.607]   - Field: 'calls'
[17:28:19.608]   - Field: 'globals'
[17:28:19.608]   - Field: 'stdout'
[17:28:19.608]   - Field: 'earlySignal'
[17:28:19.608]   - Field: 'lazy'
[17:28:19.608]   - Field: 'state'
[17:28:19.609] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:19.609] - Launch lazy future ...
[17:28:19.609] Packages needed by the future expression (n = 0): <none>
[17:28:19.609] Packages needed by future strategies (n = 0): <none>
[17:28:19.610] {
[17:28:19.610]     {
[17:28:19.610]         {
[17:28:19.610]             ...future.startTime <- base::Sys.time()
[17:28:19.610]             {
[17:28:19.610]                 {
[17:28:19.610]                   {
[17:28:19.610]                     {
[17:28:19.610]                       {
[17:28:19.610]                         base::local({
[17:28:19.610]                           has_future <- base::requireNamespace("future", 
[17:28:19.610]                             quietly = TRUE)
[17:28:19.610]                           if (has_future) {
[17:28:19.610]                             ns <- base::getNamespace("future")
[17:28:19.610]                             version <- ns[[".package"]][["version"]]
[17:28:19.610]                             if (is.null(version)) 
[17:28:19.610]                               version <- utils::packageVersion("future")
[17:28:19.610]                           }
[17:28:19.610]                           else {
[17:28:19.610]                             version <- NULL
[17:28:19.610]                           }
[17:28:19.610]                           if (!has_future || version < "1.8.0") {
[17:28:19.610]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:19.610]                               "", base::R.version$version.string), 
[17:28:19.610]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:19.610]                                 base::R.version$platform, 8 * 
[17:28:19.610]                                   base::.Machine$sizeof.pointer), 
[17:28:19.610]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:19.610]                                 "release", "version")], collapse = " "), 
[17:28:19.610]                               hostname = base::Sys.info()[["nodename"]])
[17:28:19.610]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:19.610]                               info)
[17:28:19.610]                             info <- base::paste(info, collapse = "; ")
[17:28:19.610]                             if (!has_future) {
[17:28:19.610]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:19.610]                                 info)
[17:28:19.610]                             }
[17:28:19.610]                             else {
[17:28:19.610]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:19.610]                                 info, version)
[17:28:19.610]                             }
[17:28:19.610]                             base::stop(msg)
[17:28:19.610]                           }
[17:28:19.610]                         })
[17:28:19.610]                       }
[17:28:19.610]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:19.610]                       base::options(mc.cores = 1L)
[17:28:19.610]                     }
[17:28:19.610]                     ...future.strategy.old <- future::plan("list")
[17:28:19.610]                     options(future.plan = NULL)
[17:28:19.610]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.610]                     future::plan("default", .cleanup = FALSE, 
[17:28:19.610]                       .init = FALSE)
[17:28:19.610]                   }
[17:28:19.610]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:28:19.610]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:28:19.610]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:28:19.610]                 }
[17:28:19.610]                 ...future.workdir <- getwd()
[17:28:19.610]             }
[17:28:19.610]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:19.610]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:19.610]         }
[17:28:19.610]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:19.610]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:19.610]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:19.610]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:19.610]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:19.610]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:19.610]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:19.610]             base::names(...future.oldOptions))
[17:28:19.610]     }
[17:28:19.610]     if (FALSE) {
[17:28:19.610]     }
[17:28:19.610]     else {
[17:28:19.610]         if (TRUE) {
[17:28:19.610]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:19.610]                 open = "w")
[17:28:19.610]         }
[17:28:19.610]         else {
[17:28:19.610]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:19.610]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:19.610]         }
[17:28:19.610]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:19.610]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:19.610]             base::sink(type = "output", split = FALSE)
[17:28:19.610]             base::close(...future.stdout)
[17:28:19.610]         }, add = TRUE)
[17:28:19.610]     }
[17:28:19.610]     ...future.frame <- base::sys.nframe()
[17:28:19.610]     ...future.conditions <- base::list()
[17:28:19.610]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:19.610]     if (FALSE) {
[17:28:19.610]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:19.610]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:19.610]     }
[17:28:19.610]     ...future.result <- base::tryCatch({
[17:28:19.610]         base::withCallingHandlers({
[17:28:19.610]             ...future.value <- base::withVisible(base::local({
[17:28:19.610]                 ...future.makeSendCondition <- base::local({
[17:28:19.610]                   sendCondition <- NULL
[17:28:19.610]                   function(frame = 1L) {
[17:28:19.610]                     if (is.function(sendCondition)) 
[17:28:19.610]                       return(sendCondition)
[17:28:19.610]                     ns <- getNamespace("parallel")
[17:28:19.610]                     if (exists("sendData", mode = "function", 
[17:28:19.610]                       envir = ns)) {
[17:28:19.610]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:19.610]                         envir = ns)
[17:28:19.610]                       envir <- sys.frame(frame)
[17:28:19.610]                       master <- NULL
[17:28:19.610]                       while (!identical(envir, .GlobalEnv) && 
[17:28:19.610]                         !identical(envir, emptyenv())) {
[17:28:19.610]                         if (exists("master", mode = "list", envir = envir, 
[17:28:19.610]                           inherits = FALSE)) {
[17:28:19.610]                           master <- get("master", mode = "list", 
[17:28:19.610]                             envir = envir, inherits = FALSE)
[17:28:19.610]                           if (inherits(master, c("SOCKnode", 
[17:28:19.610]                             "SOCK0node"))) {
[17:28:19.610]                             sendCondition <<- function(cond) {
[17:28:19.610]                               data <- list(type = "VALUE", value = cond, 
[17:28:19.610]                                 success = TRUE)
[17:28:19.610]                               parallel_sendData(master, data)
[17:28:19.610]                             }
[17:28:19.610]                             return(sendCondition)
[17:28:19.610]                           }
[17:28:19.610]                         }
[17:28:19.610]                         frame <- frame + 1L
[17:28:19.610]                         envir <- sys.frame(frame)
[17:28:19.610]                       }
[17:28:19.610]                     }
[17:28:19.610]                     sendCondition <<- function(cond) NULL
[17:28:19.610]                   }
[17:28:19.610]                 })
[17:28:19.610]                 withCallingHandlers({
[17:28:19.610]                   {
[17:28:19.610]                     sample(x, size = 1L)
[17:28:19.610]                   }
[17:28:19.610]                 }, immediateCondition = function(cond) {
[17:28:19.610]                   sendCondition <- ...future.makeSendCondition()
[17:28:19.610]                   sendCondition(cond)
[17:28:19.610]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.610]                   {
[17:28:19.610]                     inherits <- base::inherits
[17:28:19.610]                     invokeRestart <- base::invokeRestart
[17:28:19.610]                     is.null <- base::is.null
[17:28:19.610]                     muffled <- FALSE
[17:28:19.610]                     if (inherits(cond, "message")) {
[17:28:19.610]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:19.610]                       if (muffled) 
[17:28:19.610]                         invokeRestart("muffleMessage")
[17:28:19.610]                     }
[17:28:19.610]                     else if (inherits(cond, "warning")) {
[17:28:19.610]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:19.610]                       if (muffled) 
[17:28:19.610]                         invokeRestart("muffleWarning")
[17:28:19.610]                     }
[17:28:19.610]                     else if (inherits(cond, "condition")) {
[17:28:19.610]                       if (!is.null(pattern)) {
[17:28:19.610]                         computeRestarts <- base::computeRestarts
[17:28:19.610]                         grepl <- base::grepl
[17:28:19.610]                         restarts <- computeRestarts(cond)
[17:28:19.610]                         for (restart in restarts) {
[17:28:19.610]                           name <- restart$name
[17:28:19.610]                           if (is.null(name)) 
[17:28:19.610]                             next
[17:28:19.610]                           if (!grepl(pattern, name)) 
[17:28:19.610]                             next
[17:28:19.610]                           invokeRestart(restart)
[17:28:19.610]                           muffled <- TRUE
[17:28:19.610]                           break
[17:28:19.610]                         }
[17:28:19.610]                       }
[17:28:19.610]                     }
[17:28:19.610]                     invisible(muffled)
[17:28:19.610]                   }
[17:28:19.610]                   muffleCondition(cond)
[17:28:19.610]                 })
[17:28:19.610]             }))
[17:28:19.610]             future::FutureResult(value = ...future.value$value, 
[17:28:19.610]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.610]                   ...future.rng), globalenv = if (FALSE) 
[17:28:19.610]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:19.610]                     ...future.globalenv.names))
[17:28:19.610]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:19.610]         }, condition = base::local({
[17:28:19.610]             c <- base::c
[17:28:19.610]             inherits <- base::inherits
[17:28:19.610]             invokeRestart <- base::invokeRestart
[17:28:19.610]             length <- base::length
[17:28:19.610]             list <- base::list
[17:28:19.610]             seq.int <- base::seq.int
[17:28:19.610]             signalCondition <- base::signalCondition
[17:28:19.610]             sys.calls <- base::sys.calls
[17:28:19.610]             `[[` <- base::`[[`
[17:28:19.610]             `+` <- base::`+`
[17:28:19.610]             `<<-` <- base::`<<-`
[17:28:19.610]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:19.610]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:19.610]                   3L)]
[17:28:19.610]             }
[17:28:19.610]             function(cond) {
[17:28:19.610]                 is_error <- inherits(cond, "error")
[17:28:19.610]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:19.610]                   NULL)
[17:28:19.610]                 if (is_error) {
[17:28:19.610]                   sessionInformation <- function() {
[17:28:19.610]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:19.610]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:19.610]                       search = base::search(), system = base::Sys.info())
[17:28:19.610]                   }
[17:28:19.610]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.610]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:19.610]                     cond$call), session = sessionInformation(), 
[17:28:19.610]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:19.610]                   signalCondition(cond)
[17:28:19.610]                 }
[17:28:19.610]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:19.610]                 "immediateCondition"))) {
[17:28:19.610]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:19.610]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.610]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:19.610]                   if (TRUE && !signal) {
[17:28:19.610]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.610]                     {
[17:28:19.610]                       inherits <- base::inherits
[17:28:19.610]                       invokeRestart <- base::invokeRestart
[17:28:19.610]                       is.null <- base::is.null
[17:28:19.610]                       muffled <- FALSE
[17:28:19.610]                       if (inherits(cond, "message")) {
[17:28:19.610]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.610]                         if (muffled) 
[17:28:19.610]                           invokeRestart("muffleMessage")
[17:28:19.610]                       }
[17:28:19.610]                       else if (inherits(cond, "warning")) {
[17:28:19.610]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.610]                         if (muffled) 
[17:28:19.610]                           invokeRestart("muffleWarning")
[17:28:19.610]                       }
[17:28:19.610]                       else if (inherits(cond, "condition")) {
[17:28:19.610]                         if (!is.null(pattern)) {
[17:28:19.610]                           computeRestarts <- base::computeRestarts
[17:28:19.610]                           grepl <- base::grepl
[17:28:19.610]                           restarts <- computeRestarts(cond)
[17:28:19.610]                           for (restart in restarts) {
[17:28:19.610]                             name <- restart$name
[17:28:19.610]                             if (is.null(name)) 
[17:28:19.610]                               next
[17:28:19.610]                             if (!grepl(pattern, name)) 
[17:28:19.610]                               next
[17:28:19.610]                             invokeRestart(restart)
[17:28:19.610]                             muffled <- TRUE
[17:28:19.610]                             break
[17:28:19.610]                           }
[17:28:19.610]                         }
[17:28:19.610]                       }
[17:28:19.610]                       invisible(muffled)
[17:28:19.610]                     }
[17:28:19.610]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.610]                   }
[17:28:19.610]                 }
[17:28:19.610]                 else {
[17:28:19.610]                   if (TRUE) {
[17:28:19.610]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.610]                     {
[17:28:19.610]                       inherits <- base::inherits
[17:28:19.610]                       invokeRestart <- base::invokeRestart
[17:28:19.610]                       is.null <- base::is.null
[17:28:19.610]                       muffled <- FALSE
[17:28:19.610]                       if (inherits(cond, "message")) {
[17:28:19.610]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.610]                         if (muffled) 
[17:28:19.610]                           invokeRestart("muffleMessage")
[17:28:19.610]                       }
[17:28:19.610]                       else if (inherits(cond, "warning")) {
[17:28:19.610]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.610]                         if (muffled) 
[17:28:19.610]                           invokeRestart("muffleWarning")
[17:28:19.610]                       }
[17:28:19.610]                       else if (inherits(cond, "condition")) {
[17:28:19.610]                         if (!is.null(pattern)) {
[17:28:19.610]                           computeRestarts <- base::computeRestarts
[17:28:19.610]                           grepl <- base::grepl
[17:28:19.610]                           restarts <- computeRestarts(cond)
[17:28:19.610]                           for (restart in restarts) {
[17:28:19.610]                             name <- restart$name
[17:28:19.610]                             if (is.null(name)) 
[17:28:19.610]                               next
[17:28:19.610]                             if (!grepl(pattern, name)) 
[17:28:19.610]                               next
[17:28:19.610]                             invokeRestart(restart)
[17:28:19.610]                             muffled <- TRUE
[17:28:19.610]                             break
[17:28:19.610]                           }
[17:28:19.610]                         }
[17:28:19.610]                       }
[17:28:19.610]                       invisible(muffled)
[17:28:19.610]                     }
[17:28:19.610]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.610]                   }
[17:28:19.610]                 }
[17:28:19.610]             }
[17:28:19.610]         }))
[17:28:19.610]     }, error = function(ex) {
[17:28:19.610]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:19.610]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.610]                 ...future.rng), started = ...future.startTime, 
[17:28:19.610]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:19.610]             version = "1.8"), class = "FutureResult")
[17:28:19.610]     }, finally = {
[17:28:19.610]         if (!identical(...future.workdir, getwd())) 
[17:28:19.610]             setwd(...future.workdir)
[17:28:19.610]         {
[17:28:19.610]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:19.610]                 ...future.oldOptions$nwarnings <- NULL
[17:28:19.610]             }
[17:28:19.610]             base::options(...future.oldOptions)
[17:28:19.610]             if (.Platform$OS.type == "windows") {
[17:28:19.610]                 old_names <- names(...future.oldEnvVars)
[17:28:19.610]                 envs <- base::Sys.getenv()
[17:28:19.610]                 names <- names(envs)
[17:28:19.610]                 common <- intersect(names, old_names)
[17:28:19.610]                 added <- setdiff(names, old_names)
[17:28:19.610]                 removed <- setdiff(old_names, names)
[17:28:19.610]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:19.610]                   envs[common]]
[17:28:19.610]                 NAMES <- toupper(changed)
[17:28:19.610]                 args <- list()
[17:28:19.610]                 for (kk in seq_along(NAMES)) {
[17:28:19.610]                   name <- changed[[kk]]
[17:28:19.610]                   NAME <- NAMES[[kk]]
[17:28:19.610]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.610]                     next
[17:28:19.610]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.610]                 }
[17:28:19.610]                 NAMES <- toupper(added)
[17:28:19.610]                 for (kk in seq_along(NAMES)) {
[17:28:19.610]                   name <- added[[kk]]
[17:28:19.610]                   NAME <- NAMES[[kk]]
[17:28:19.610]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.610]                     next
[17:28:19.610]                   args[[name]] <- ""
[17:28:19.610]                 }
[17:28:19.610]                 NAMES <- toupper(removed)
[17:28:19.610]                 for (kk in seq_along(NAMES)) {
[17:28:19.610]                   name <- removed[[kk]]
[17:28:19.610]                   NAME <- NAMES[[kk]]
[17:28:19.610]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.610]                     next
[17:28:19.610]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.610]                 }
[17:28:19.610]                 if (length(args) > 0) 
[17:28:19.610]                   base::do.call(base::Sys.setenv, args = args)
[17:28:19.610]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:19.610]             }
[17:28:19.610]             else {
[17:28:19.610]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:19.610]             }
[17:28:19.610]             {
[17:28:19.610]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:19.610]                   0L) {
[17:28:19.610]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:19.610]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:19.610]                   base::options(opts)
[17:28:19.610]                 }
[17:28:19.610]                 {
[17:28:19.610]                   {
[17:28:19.610]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:19.610]                     NULL
[17:28:19.610]                   }
[17:28:19.610]                   options(future.plan = NULL)
[17:28:19.610]                   if (is.na(NA_character_)) 
[17:28:19.610]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.610]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:19.610]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:19.610]                     .init = FALSE)
[17:28:19.610]                 }
[17:28:19.610]             }
[17:28:19.610]         }
[17:28:19.610]     })
[17:28:19.610]     if (TRUE) {
[17:28:19.610]         base::sink(type = "output", split = FALSE)
[17:28:19.610]         if (TRUE) {
[17:28:19.610]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:19.610]         }
[17:28:19.610]         else {
[17:28:19.610]             ...future.result["stdout"] <- base::list(NULL)
[17:28:19.610]         }
[17:28:19.610]         base::close(...future.stdout)
[17:28:19.610]         ...future.stdout <- NULL
[17:28:19.610]     }
[17:28:19.610]     ...future.result$conditions <- ...future.conditions
[17:28:19.610]     ...future.result$finished <- base::Sys.time()
[17:28:19.610]     ...future.result
[17:28:19.610] }
[17:28:19.614] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:19.649] receiveMessageFromWorker() for ClusterFuture ...
[17:28:19.649] - Validating connection of MultisessionFuture
[17:28:19.650] - received message: FutureResult
[17:28:19.650] - Received FutureResult
[17:28:19.650] - Erased future from FutureRegistry
[17:28:19.650] result() for ClusterFuture ...
[17:28:19.650] - result already collected: FutureResult
[17:28:19.651] result() for ClusterFuture ... done
[17:28:19.651] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:19.651] result() for ClusterFuture ...
[17:28:19.651] - result already collected: FutureResult
[17:28:19.651] result() for ClusterFuture ... done
[17:28:19.651] result() for ClusterFuture ...
[17:28:19.652] - result already collected: FutureResult
[17:28:19.652] result() for ClusterFuture ... done
[17:28:19.652] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:19.653] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:19.653] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:19.653] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:19.654] MultisessionFuture started
[17:28:19.654] - Launch lazy future ... done
[17:28:19.654] run() for 'MultisessionFuture' ... done
[17:28:19.654] resolve() on list ...
[17:28:19.655]  recursive: 0
[17:28:19.655]  length: 4
[17:28:19.655] 
[17:28:19.655] Future #1
[17:28:19.655] result() for ClusterFuture ...
[17:28:19.656] - result already collected: FutureResult
[17:28:19.656] result() for ClusterFuture ... done
[17:28:19.656] result() for ClusterFuture ...
[17:28:19.656] - result already collected: FutureResult
[17:28:19.656] result() for ClusterFuture ... done
[17:28:19.656] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:28:19.656] - nx: 4
[17:28:19.657] - relay: TRUE
[17:28:19.657] - stdout: TRUE
[17:28:19.657] - signal: TRUE
[17:28:19.657] - resignal: FALSE
[17:28:19.657] - force: TRUE
[17:28:19.657] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:19.658] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:19.658]  - until=1
[17:28:19.658]  - relaying element #1
[17:28:19.658] result() for ClusterFuture ...
[17:28:19.658] - result already collected: FutureResult
[17:28:19.658] result() for ClusterFuture ... done
[17:28:19.659] result() for ClusterFuture ...
[17:28:19.659] - result already collected: FutureResult
[17:28:19.659] result() for ClusterFuture ... done
[17:28:19.659] result() for ClusterFuture ...
[17:28:19.659] - result already collected: FutureResult
[17:28:19.659] result() for ClusterFuture ... done
[17:28:19.660] result() for ClusterFuture ...
[17:28:19.660] - result already collected: FutureResult
[17:28:19.660] result() for ClusterFuture ... done
[17:28:19.660] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:19.660] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:19.660] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[17:28:19.661]  length: 3 (resolved future 1)
[17:28:19.661] Future #2
[17:28:19.661] result() for ClusterFuture ...
[17:28:19.661] - result already collected: FutureResult
[17:28:19.661] result() for ClusterFuture ... done
[17:28:19.661] result() for ClusterFuture ...
[17:28:19.662] - result already collected: FutureResult
[17:28:19.662] result() for ClusterFuture ... done
[17:28:19.662] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:28:19.662] - nx: 4
[17:28:19.662] - relay: TRUE
[17:28:19.662] - stdout: TRUE
[17:28:19.662] - signal: TRUE
[17:28:19.663] - resignal: FALSE
[17:28:19.663] - force: TRUE
[17:28:19.663] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:19.663] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:19.663]  - until=2
[17:28:19.663]  - relaying element #2
[17:28:19.664] result() for ClusterFuture ...
[17:28:19.664] - result already collected: FutureResult
[17:28:19.664] result() for ClusterFuture ... done
[17:28:19.664] result() for ClusterFuture ...
[17:28:19.664] - result already collected: FutureResult
[17:28:19.664] result() for ClusterFuture ... done
[17:28:19.665] result() for ClusterFuture ...
[17:28:19.665] - result already collected: FutureResult
[17:28:19.665] result() for ClusterFuture ... done
[17:28:19.665] result() for ClusterFuture ...
[17:28:19.665] - result already collected: FutureResult
[17:28:19.665] result() for ClusterFuture ... done
[17:28:19.666] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:19.666] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:19.666] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:28:19.666]  length: 2 (resolved future 2)
[17:28:19.666] receiveMessageFromWorker() for ClusterFuture ...
[17:28:19.667] - Validating connection of MultisessionFuture
[17:28:19.667] - received message: FutureResult
[17:28:19.667] - Received FutureResult
[17:28:19.667] - Erased future from FutureRegistry
[17:28:19.667] result() for ClusterFuture ...
[17:28:19.668] - result already collected: FutureResult
[17:28:19.668] result() for ClusterFuture ... done
[17:28:19.668] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:19.668] Future #3
[17:28:19.668] result() for ClusterFuture ...
[17:28:19.668] - result already collected: FutureResult
[17:28:19.669] result() for ClusterFuture ... done
[17:28:19.669] result() for ClusterFuture ...
[17:28:19.669] - result already collected: FutureResult
[17:28:19.669] result() for ClusterFuture ... done
[17:28:19.669] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:28:19.669] - nx: 4
[17:28:19.670] - relay: TRUE
[17:28:19.670] - stdout: TRUE
[17:28:19.670] - signal: TRUE
[17:28:19.670] - resignal: FALSE
[17:28:19.670] - force: TRUE
[17:28:19.670] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:19.670] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:19.671]  - until=3
[17:28:19.671]  - relaying element #3
[17:28:19.671] result() for ClusterFuture ...
[17:28:19.671] - result already collected: FutureResult
[17:28:19.671] result() for ClusterFuture ... done
[17:28:19.671] result() for ClusterFuture ...
[17:28:19.672] - result already collected: FutureResult
[17:28:19.672] result() for ClusterFuture ... done
[17:28:19.672] result() for ClusterFuture ...
[17:28:19.672] - result already collected: FutureResult
[17:28:19.672] result() for ClusterFuture ... done
[17:28:19.672] result() for ClusterFuture ...
[17:28:19.673] - result already collected: FutureResult
[17:28:19.673] result() for ClusterFuture ... done
[17:28:19.673] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:19.673] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:19.673] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:28:19.673]  length: 1 (resolved future 3)
[17:28:19.674] receiveMessageFromWorker() for ClusterFuture ...
[17:28:19.674] - Validating connection of MultisessionFuture
[17:28:19.674] - received message: FutureResult
[17:28:19.674] - Received FutureResult
[17:28:19.675] - Erased future from FutureRegistry
[17:28:19.675] result() for ClusterFuture ...
[17:28:19.675] - result already collected: FutureResult
[17:28:19.675] result() for ClusterFuture ... done
[17:28:19.675] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:19.675] Future #4
[17:28:19.676] result() for ClusterFuture ...
[17:28:19.676] - result already collected: FutureResult
[17:28:19.676] result() for ClusterFuture ... done
[17:28:19.676] result() for ClusterFuture ...
[17:28:19.676] - result already collected: FutureResult
[17:28:19.676] result() for ClusterFuture ... done
[17:28:19.677] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:28:19.677] - nx: 4
[17:28:19.677] - relay: TRUE
[17:28:19.677] - stdout: TRUE
[17:28:19.677] - signal: TRUE
[17:28:19.677] - resignal: FALSE
[17:28:19.677] - force: TRUE
[17:28:19.678] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:19.678] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:19.678]  - until=4
[17:28:19.678]  - relaying element #4
[17:28:19.678] result() for ClusterFuture ...
[17:28:19.678] - result already collected: FutureResult
[17:28:19.679] result() for ClusterFuture ... done
[17:28:19.679] result() for ClusterFuture ...
[17:28:19.679] - result already collected: FutureResult
[17:28:19.679] result() for ClusterFuture ... done
[17:28:19.679] result() for ClusterFuture ...
[17:28:19.679] - result already collected: FutureResult
[17:28:19.680] result() for ClusterFuture ... done
[17:28:19.680] result() for ClusterFuture ...
[17:28:19.680] - result already collected: FutureResult
[17:28:19.680] result() for ClusterFuture ... done
[17:28:19.680] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:19.680] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:19.680] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:28:19.681]  length: 0 (resolved future 4)
[17:28:19.681] Relaying remaining futures
[17:28:19.681] signalConditionsASAP(NULL, pos=0) ...
[17:28:19.681] - nx: 4
[17:28:19.681] - relay: TRUE
[17:28:19.681] - stdout: TRUE
[17:28:19.682] - signal: TRUE
[17:28:19.682] - resignal: FALSE
[17:28:19.682] - force: TRUE
[17:28:19.682] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:19.682] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:28:19.682] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:19.683] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:19.683] signalConditionsASAP(NULL, pos=0) ... done
[17:28:19.683] resolve() on list ... DONE
[17:28:19.683] result() for ClusterFuture ...
[17:28:19.683] - result already collected: FutureResult
[17:28:19.683] result() for ClusterFuture ... done
[17:28:19.684] result() for ClusterFuture ...
[17:28:19.684] - result already collected: FutureResult
[17:28:19.684] result() for ClusterFuture ... done
[17:28:19.684] result() for ClusterFuture ...
[17:28:19.684] - result already collected: FutureResult
[17:28:19.684] result() for ClusterFuture ... done
[17:28:19.685] result() for ClusterFuture ...
[17:28:19.685] - result already collected: FutureResult
[17:28:19.685] result() for ClusterFuture ... done
[17:28:19.685] result() for ClusterFuture ...
[17:28:19.685] - result already collected: FutureResult
[17:28:19.685] result() for ClusterFuture ... done
[17:28:19.685] result() for ClusterFuture ...
[17:28:19.686] - result already collected: FutureResult
[17:28:19.686] result() for ClusterFuture ... done
[17:28:19.686] result() for ClusterFuture ...
[17:28:19.686] - result already collected: FutureResult
[17:28:19.686] result() for ClusterFuture ... done
[17:28:19.686] result() for ClusterFuture ...
[17:28:19.687] - result already collected: FutureResult
[17:28:19.687] result() for ClusterFuture ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[17:28:19.687] getGlobalsAndPackages() ...
[17:28:19.687] Searching for globals...
[17:28:19.689] - globals found: [3] '{', 'sample', 'x'
[17:28:19.689] Searching for globals ... DONE
[17:28:19.689] Resolving globals: FALSE
[17:28:19.689] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:19.690] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:19.690] - globals: [1] 'x'
[17:28:19.690] 
[17:28:19.690] getGlobalsAndPackages() ... DONE
[17:28:19.691] run() for 'Future' ...
[17:28:19.691] - state: 'created'
[17:28:19.691] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:19.704] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:19.705] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:19.705]   - Field: 'node'
[17:28:19.705]   - Field: 'label'
[17:28:19.705]   - Field: 'local'
[17:28:19.705]   - Field: 'owner'
[17:28:19.706]   - Field: 'envir'
[17:28:19.706]   - Field: 'workers'
[17:28:19.706]   - Field: 'packages'
[17:28:19.706]   - Field: 'gc'
[17:28:19.706]   - Field: 'conditions'
[17:28:19.707]   - Field: 'persistent'
[17:28:19.707]   - Field: 'expr'
[17:28:19.707]   - Field: 'uuid'
[17:28:19.707]   - Field: 'seed'
[17:28:19.707]   - Field: 'version'
[17:28:19.707]   - Field: 'result'
[17:28:19.708]   - Field: 'asynchronous'
[17:28:19.708]   - Field: 'calls'
[17:28:19.708]   - Field: 'globals'
[17:28:19.708]   - Field: 'stdout'
[17:28:19.708]   - Field: 'earlySignal'
[17:28:19.708]   - Field: 'lazy'
[17:28:19.709]   - Field: 'state'
[17:28:19.709] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:19.709] - Launch lazy future ...
[17:28:19.709] Packages needed by the future expression (n = 0): <none>
[17:28:19.710] Packages needed by future strategies (n = 0): <none>
[17:28:19.710] {
[17:28:19.710]     {
[17:28:19.710]         {
[17:28:19.710]             ...future.startTime <- base::Sys.time()
[17:28:19.710]             {
[17:28:19.710]                 {
[17:28:19.710]                   {
[17:28:19.710]                     {
[17:28:19.710]                       {
[17:28:19.710]                         base::local({
[17:28:19.710]                           has_future <- base::requireNamespace("future", 
[17:28:19.710]                             quietly = TRUE)
[17:28:19.710]                           if (has_future) {
[17:28:19.710]                             ns <- base::getNamespace("future")
[17:28:19.710]                             version <- ns[[".package"]][["version"]]
[17:28:19.710]                             if (is.null(version)) 
[17:28:19.710]                               version <- utils::packageVersion("future")
[17:28:19.710]                           }
[17:28:19.710]                           else {
[17:28:19.710]                             version <- NULL
[17:28:19.710]                           }
[17:28:19.710]                           if (!has_future || version < "1.8.0") {
[17:28:19.710]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:19.710]                               "", base::R.version$version.string), 
[17:28:19.710]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:19.710]                                 base::R.version$platform, 8 * 
[17:28:19.710]                                   base::.Machine$sizeof.pointer), 
[17:28:19.710]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:19.710]                                 "release", "version")], collapse = " "), 
[17:28:19.710]                               hostname = base::Sys.info()[["nodename"]])
[17:28:19.710]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:19.710]                               info)
[17:28:19.710]                             info <- base::paste(info, collapse = "; ")
[17:28:19.710]                             if (!has_future) {
[17:28:19.710]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:19.710]                                 info)
[17:28:19.710]                             }
[17:28:19.710]                             else {
[17:28:19.710]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:19.710]                                 info, version)
[17:28:19.710]                             }
[17:28:19.710]                             base::stop(msg)
[17:28:19.710]                           }
[17:28:19.710]                         })
[17:28:19.710]                       }
[17:28:19.710]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:19.710]                       base::options(mc.cores = 1L)
[17:28:19.710]                     }
[17:28:19.710]                     ...future.strategy.old <- future::plan("list")
[17:28:19.710]                     options(future.plan = NULL)
[17:28:19.710]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.710]                     future::plan("default", .cleanup = FALSE, 
[17:28:19.710]                       .init = FALSE)
[17:28:19.710]                   }
[17:28:19.710]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:28:19.710]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:28:19.710]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:28:19.710]                 }
[17:28:19.710]                 ...future.workdir <- getwd()
[17:28:19.710]             }
[17:28:19.710]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:19.710]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:19.710]         }
[17:28:19.710]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:19.710]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:19.710]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:19.710]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:19.710]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:19.710]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:19.710]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:19.710]             base::names(...future.oldOptions))
[17:28:19.710]     }
[17:28:19.710]     if (FALSE) {
[17:28:19.710]     }
[17:28:19.710]     else {
[17:28:19.710]         if (TRUE) {
[17:28:19.710]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:19.710]                 open = "w")
[17:28:19.710]         }
[17:28:19.710]         else {
[17:28:19.710]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:19.710]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:19.710]         }
[17:28:19.710]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:19.710]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:19.710]             base::sink(type = "output", split = FALSE)
[17:28:19.710]             base::close(...future.stdout)
[17:28:19.710]         }, add = TRUE)
[17:28:19.710]     }
[17:28:19.710]     ...future.frame <- base::sys.nframe()
[17:28:19.710]     ...future.conditions <- base::list()
[17:28:19.710]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:19.710]     if (FALSE) {
[17:28:19.710]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:19.710]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:19.710]     }
[17:28:19.710]     ...future.result <- base::tryCatch({
[17:28:19.710]         base::withCallingHandlers({
[17:28:19.710]             ...future.value <- base::withVisible(base::local({
[17:28:19.710]                 ...future.makeSendCondition <- base::local({
[17:28:19.710]                   sendCondition <- NULL
[17:28:19.710]                   function(frame = 1L) {
[17:28:19.710]                     if (is.function(sendCondition)) 
[17:28:19.710]                       return(sendCondition)
[17:28:19.710]                     ns <- getNamespace("parallel")
[17:28:19.710]                     if (exists("sendData", mode = "function", 
[17:28:19.710]                       envir = ns)) {
[17:28:19.710]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:19.710]                         envir = ns)
[17:28:19.710]                       envir <- sys.frame(frame)
[17:28:19.710]                       master <- NULL
[17:28:19.710]                       while (!identical(envir, .GlobalEnv) && 
[17:28:19.710]                         !identical(envir, emptyenv())) {
[17:28:19.710]                         if (exists("master", mode = "list", envir = envir, 
[17:28:19.710]                           inherits = FALSE)) {
[17:28:19.710]                           master <- get("master", mode = "list", 
[17:28:19.710]                             envir = envir, inherits = FALSE)
[17:28:19.710]                           if (inherits(master, c("SOCKnode", 
[17:28:19.710]                             "SOCK0node"))) {
[17:28:19.710]                             sendCondition <<- function(cond) {
[17:28:19.710]                               data <- list(type = "VALUE", value = cond, 
[17:28:19.710]                                 success = TRUE)
[17:28:19.710]                               parallel_sendData(master, data)
[17:28:19.710]                             }
[17:28:19.710]                             return(sendCondition)
[17:28:19.710]                           }
[17:28:19.710]                         }
[17:28:19.710]                         frame <- frame + 1L
[17:28:19.710]                         envir <- sys.frame(frame)
[17:28:19.710]                       }
[17:28:19.710]                     }
[17:28:19.710]                     sendCondition <<- function(cond) NULL
[17:28:19.710]                   }
[17:28:19.710]                 })
[17:28:19.710]                 withCallingHandlers({
[17:28:19.710]                   {
[17:28:19.710]                     sample(x, size = 1L)
[17:28:19.710]                   }
[17:28:19.710]                 }, immediateCondition = function(cond) {
[17:28:19.710]                   sendCondition <- ...future.makeSendCondition()
[17:28:19.710]                   sendCondition(cond)
[17:28:19.710]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.710]                   {
[17:28:19.710]                     inherits <- base::inherits
[17:28:19.710]                     invokeRestart <- base::invokeRestart
[17:28:19.710]                     is.null <- base::is.null
[17:28:19.710]                     muffled <- FALSE
[17:28:19.710]                     if (inherits(cond, "message")) {
[17:28:19.710]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:19.710]                       if (muffled) 
[17:28:19.710]                         invokeRestart("muffleMessage")
[17:28:19.710]                     }
[17:28:19.710]                     else if (inherits(cond, "warning")) {
[17:28:19.710]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:19.710]                       if (muffled) 
[17:28:19.710]                         invokeRestart("muffleWarning")
[17:28:19.710]                     }
[17:28:19.710]                     else if (inherits(cond, "condition")) {
[17:28:19.710]                       if (!is.null(pattern)) {
[17:28:19.710]                         computeRestarts <- base::computeRestarts
[17:28:19.710]                         grepl <- base::grepl
[17:28:19.710]                         restarts <- computeRestarts(cond)
[17:28:19.710]                         for (restart in restarts) {
[17:28:19.710]                           name <- restart$name
[17:28:19.710]                           if (is.null(name)) 
[17:28:19.710]                             next
[17:28:19.710]                           if (!grepl(pattern, name)) 
[17:28:19.710]                             next
[17:28:19.710]                           invokeRestart(restart)
[17:28:19.710]                           muffled <- TRUE
[17:28:19.710]                           break
[17:28:19.710]                         }
[17:28:19.710]                       }
[17:28:19.710]                     }
[17:28:19.710]                     invisible(muffled)
[17:28:19.710]                   }
[17:28:19.710]                   muffleCondition(cond)
[17:28:19.710]                 })
[17:28:19.710]             }))
[17:28:19.710]             future::FutureResult(value = ...future.value$value, 
[17:28:19.710]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.710]                   ...future.rng), globalenv = if (FALSE) 
[17:28:19.710]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:19.710]                     ...future.globalenv.names))
[17:28:19.710]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:19.710]         }, condition = base::local({
[17:28:19.710]             c <- base::c
[17:28:19.710]             inherits <- base::inherits
[17:28:19.710]             invokeRestart <- base::invokeRestart
[17:28:19.710]             length <- base::length
[17:28:19.710]             list <- base::list
[17:28:19.710]             seq.int <- base::seq.int
[17:28:19.710]             signalCondition <- base::signalCondition
[17:28:19.710]             sys.calls <- base::sys.calls
[17:28:19.710]             `[[` <- base::`[[`
[17:28:19.710]             `+` <- base::`+`
[17:28:19.710]             `<<-` <- base::`<<-`
[17:28:19.710]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:19.710]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:19.710]                   3L)]
[17:28:19.710]             }
[17:28:19.710]             function(cond) {
[17:28:19.710]                 is_error <- inherits(cond, "error")
[17:28:19.710]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:19.710]                   NULL)
[17:28:19.710]                 if (is_error) {
[17:28:19.710]                   sessionInformation <- function() {
[17:28:19.710]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:19.710]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:19.710]                       search = base::search(), system = base::Sys.info())
[17:28:19.710]                   }
[17:28:19.710]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.710]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:19.710]                     cond$call), session = sessionInformation(), 
[17:28:19.710]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:19.710]                   signalCondition(cond)
[17:28:19.710]                 }
[17:28:19.710]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:19.710]                 "immediateCondition"))) {
[17:28:19.710]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:19.710]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.710]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:19.710]                   if (TRUE && !signal) {
[17:28:19.710]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.710]                     {
[17:28:19.710]                       inherits <- base::inherits
[17:28:19.710]                       invokeRestart <- base::invokeRestart
[17:28:19.710]                       is.null <- base::is.null
[17:28:19.710]                       muffled <- FALSE
[17:28:19.710]                       if (inherits(cond, "message")) {
[17:28:19.710]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.710]                         if (muffled) 
[17:28:19.710]                           invokeRestart("muffleMessage")
[17:28:19.710]                       }
[17:28:19.710]                       else if (inherits(cond, "warning")) {
[17:28:19.710]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.710]                         if (muffled) 
[17:28:19.710]                           invokeRestart("muffleWarning")
[17:28:19.710]                       }
[17:28:19.710]                       else if (inherits(cond, "condition")) {
[17:28:19.710]                         if (!is.null(pattern)) {
[17:28:19.710]                           computeRestarts <- base::computeRestarts
[17:28:19.710]                           grepl <- base::grepl
[17:28:19.710]                           restarts <- computeRestarts(cond)
[17:28:19.710]                           for (restart in restarts) {
[17:28:19.710]                             name <- restart$name
[17:28:19.710]                             if (is.null(name)) 
[17:28:19.710]                               next
[17:28:19.710]                             if (!grepl(pattern, name)) 
[17:28:19.710]                               next
[17:28:19.710]                             invokeRestart(restart)
[17:28:19.710]                             muffled <- TRUE
[17:28:19.710]                             break
[17:28:19.710]                           }
[17:28:19.710]                         }
[17:28:19.710]                       }
[17:28:19.710]                       invisible(muffled)
[17:28:19.710]                     }
[17:28:19.710]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.710]                   }
[17:28:19.710]                 }
[17:28:19.710]                 else {
[17:28:19.710]                   if (TRUE) {
[17:28:19.710]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.710]                     {
[17:28:19.710]                       inherits <- base::inherits
[17:28:19.710]                       invokeRestart <- base::invokeRestart
[17:28:19.710]                       is.null <- base::is.null
[17:28:19.710]                       muffled <- FALSE
[17:28:19.710]                       if (inherits(cond, "message")) {
[17:28:19.710]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.710]                         if (muffled) 
[17:28:19.710]                           invokeRestart("muffleMessage")
[17:28:19.710]                       }
[17:28:19.710]                       else if (inherits(cond, "warning")) {
[17:28:19.710]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.710]                         if (muffled) 
[17:28:19.710]                           invokeRestart("muffleWarning")
[17:28:19.710]                       }
[17:28:19.710]                       else if (inherits(cond, "condition")) {
[17:28:19.710]                         if (!is.null(pattern)) {
[17:28:19.710]                           computeRestarts <- base::computeRestarts
[17:28:19.710]                           grepl <- base::grepl
[17:28:19.710]                           restarts <- computeRestarts(cond)
[17:28:19.710]                           for (restart in restarts) {
[17:28:19.710]                             name <- restart$name
[17:28:19.710]                             if (is.null(name)) 
[17:28:19.710]                               next
[17:28:19.710]                             if (!grepl(pattern, name)) 
[17:28:19.710]                               next
[17:28:19.710]                             invokeRestart(restart)
[17:28:19.710]                             muffled <- TRUE
[17:28:19.710]                             break
[17:28:19.710]                           }
[17:28:19.710]                         }
[17:28:19.710]                       }
[17:28:19.710]                       invisible(muffled)
[17:28:19.710]                     }
[17:28:19.710]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.710]                   }
[17:28:19.710]                 }
[17:28:19.710]             }
[17:28:19.710]         }))
[17:28:19.710]     }, error = function(ex) {
[17:28:19.710]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:19.710]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.710]                 ...future.rng), started = ...future.startTime, 
[17:28:19.710]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:19.710]             version = "1.8"), class = "FutureResult")
[17:28:19.710]     }, finally = {
[17:28:19.710]         if (!identical(...future.workdir, getwd())) 
[17:28:19.710]             setwd(...future.workdir)
[17:28:19.710]         {
[17:28:19.710]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:19.710]                 ...future.oldOptions$nwarnings <- NULL
[17:28:19.710]             }
[17:28:19.710]             base::options(...future.oldOptions)
[17:28:19.710]             if (.Platform$OS.type == "windows") {
[17:28:19.710]                 old_names <- names(...future.oldEnvVars)
[17:28:19.710]                 envs <- base::Sys.getenv()
[17:28:19.710]                 names <- names(envs)
[17:28:19.710]                 common <- intersect(names, old_names)
[17:28:19.710]                 added <- setdiff(names, old_names)
[17:28:19.710]                 removed <- setdiff(old_names, names)
[17:28:19.710]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:19.710]                   envs[common]]
[17:28:19.710]                 NAMES <- toupper(changed)
[17:28:19.710]                 args <- list()
[17:28:19.710]                 for (kk in seq_along(NAMES)) {
[17:28:19.710]                   name <- changed[[kk]]
[17:28:19.710]                   NAME <- NAMES[[kk]]
[17:28:19.710]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.710]                     next
[17:28:19.710]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.710]                 }
[17:28:19.710]                 NAMES <- toupper(added)
[17:28:19.710]                 for (kk in seq_along(NAMES)) {
[17:28:19.710]                   name <- added[[kk]]
[17:28:19.710]                   NAME <- NAMES[[kk]]
[17:28:19.710]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.710]                     next
[17:28:19.710]                   args[[name]] <- ""
[17:28:19.710]                 }
[17:28:19.710]                 NAMES <- toupper(removed)
[17:28:19.710]                 for (kk in seq_along(NAMES)) {
[17:28:19.710]                   name <- removed[[kk]]
[17:28:19.710]                   NAME <- NAMES[[kk]]
[17:28:19.710]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.710]                     next
[17:28:19.710]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.710]                 }
[17:28:19.710]                 if (length(args) > 0) 
[17:28:19.710]                   base::do.call(base::Sys.setenv, args = args)
[17:28:19.710]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:19.710]             }
[17:28:19.710]             else {
[17:28:19.710]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:19.710]             }
[17:28:19.710]             {
[17:28:19.710]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:19.710]                   0L) {
[17:28:19.710]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:19.710]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:19.710]                   base::options(opts)
[17:28:19.710]                 }
[17:28:19.710]                 {
[17:28:19.710]                   {
[17:28:19.710]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:19.710]                     NULL
[17:28:19.710]                   }
[17:28:19.710]                   options(future.plan = NULL)
[17:28:19.710]                   if (is.na(NA_character_)) 
[17:28:19.710]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.710]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:19.710]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:19.710]                     .init = FALSE)
[17:28:19.710]                 }
[17:28:19.710]             }
[17:28:19.710]         }
[17:28:19.710]     })
[17:28:19.710]     if (TRUE) {
[17:28:19.710]         base::sink(type = "output", split = FALSE)
[17:28:19.710]         if (TRUE) {
[17:28:19.710]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:19.710]         }
[17:28:19.710]         else {
[17:28:19.710]             ...future.result["stdout"] <- base::list(NULL)
[17:28:19.710]         }
[17:28:19.710]         base::close(...future.stdout)
[17:28:19.710]         ...future.stdout <- NULL
[17:28:19.710]     }
[17:28:19.710]     ...future.result$conditions <- ...future.conditions
[17:28:19.710]     ...future.result$finished <- base::Sys.time()
[17:28:19.710]     ...future.result
[17:28:19.710] }
[17:28:19.715] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:19.715] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:19.716] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:19.716] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:19.717] MultisessionFuture started
[17:28:19.717] - Launch lazy future ... done
[17:28:19.717] run() for 'MultisessionFuture' ... done
[17:28:19.717] getGlobalsAndPackages() ...
[17:28:19.717] Searching for globals...
[17:28:19.719] - globals found: [3] '{', 'sample', 'x'
[17:28:19.719] Searching for globals ... DONE
[17:28:19.719] Resolving globals: FALSE
[17:28:19.719] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:19.720] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:19.720] - globals: [1] 'x'
[17:28:19.720] 
[17:28:19.720] getGlobalsAndPackages() ... DONE
[17:28:19.721] run() for 'Future' ...
[17:28:19.721] - state: 'created'
[17:28:19.721] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:19.735] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:19.735] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:19.735]   - Field: 'node'
[17:28:19.735]   - Field: 'label'
[17:28:19.735]   - Field: 'local'
[17:28:19.736]   - Field: 'owner'
[17:28:19.736]   - Field: 'envir'
[17:28:19.736]   - Field: 'workers'
[17:28:19.736]   - Field: 'packages'
[17:28:19.736]   - Field: 'gc'
[17:28:19.737]   - Field: 'conditions'
[17:28:19.737]   - Field: 'persistent'
[17:28:19.737]   - Field: 'expr'
[17:28:19.737]   - Field: 'uuid'
[17:28:19.737]   - Field: 'seed'
[17:28:19.737]   - Field: 'version'
[17:28:19.738]   - Field: 'result'
[17:28:19.738]   - Field: 'asynchronous'
[17:28:19.738]   - Field: 'calls'
[17:28:19.738]   - Field: 'globals'
[17:28:19.738]   - Field: 'stdout'
[17:28:19.738]   - Field: 'earlySignal'
[17:28:19.739]   - Field: 'lazy'
[17:28:19.739]   - Field: 'state'
[17:28:19.739] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:19.739] - Launch lazy future ...
[17:28:19.740] Packages needed by the future expression (n = 0): <none>
[17:28:19.740] Packages needed by future strategies (n = 0): <none>
[17:28:19.740] {
[17:28:19.740]     {
[17:28:19.740]         {
[17:28:19.740]             ...future.startTime <- base::Sys.time()
[17:28:19.740]             {
[17:28:19.740]                 {
[17:28:19.740]                   {
[17:28:19.740]                     {
[17:28:19.740]                       {
[17:28:19.740]                         base::local({
[17:28:19.740]                           has_future <- base::requireNamespace("future", 
[17:28:19.740]                             quietly = TRUE)
[17:28:19.740]                           if (has_future) {
[17:28:19.740]                             ns <- base::getNamespace("future")
[17:28:19.740]                             version <- ns[[".package"]][["version"]]
[17:28:19.740]                             if (is.null(version)) 
[17:28:19.740]                               version <- utils::packageVersion("future")
[17:28:19.740]                           }
[17:28:19.740]                           else {
[17:28:19.740]                             version <- NULL
[17:28:19.740]                           }
[17:28:19.740]                           if (!has_future || version < "1.8.0") {
[17:28:19.740]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:19.740]                               "", base::R.version$version.string), 
[17:28:19.740]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:19.740]                                 base::R.version$platform, 8 * 
[17:28:19.740]                                   base::.Machine$sizeof.pointer), 
[17:28:19.740]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:19.740]                                 "release", "version")], collapse = " "), 
[17:28:19.740]                               hostname = base::Sys.info()[["nodename"]])
[17:28:19.740]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:19.740]                               info)
[17:28:19.740]                             info <- base::paste(info, collapse = "; ")
[17:28:19.740]                             if (!has_future) {
[17:28:19.740]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:19.740]                                 info)
[17:28:19.740]                             }
[17:28:19.740]                             else {
[17:28:19.740]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:19.740]                                 info, version)
[17:28:19.740]                             }
[17:28:19.740]                             base::stop(msg)
[17:28:19.740]                           }
[17:28:19.740]                         })
[17:28:19.740]                       }
[17:28:19.740]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:19.740]                       base::options(mc.cores = 1L)
[17:28:19.740]                     }
[17:28:19.740]                     ...future.strategy.old <- future::plan("list")
[17:28:19.740]                     options(future.plan = NULL)
[17:28:19.740]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.740]                     future::plan("default", .cleanup = FALSE, 
[17:28:19.740]                       .init = FALSE)
[17:28:19.740]                   }
[17:28:19.740]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:28:19.740]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:28:19.740]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:28:19.740]                 }
[17:28:19.740]                 ...future.workdir <- getwd()
[17:28:19.740]             }
[17:28:19.740]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:19.740]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:19.740]         }
[17:28:19.740]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:19.740]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:19.740]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:19.740]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:19.740]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:19.740]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:19.740]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:19.740]             base::names(...future.oldOptions))
[17:28:19.740]     }
[17:28:19.740]     if (FALSE) {
[17:28:19.740]     }
[17:28:19.740]     else {
[17:28:19.740]         if (TRUE) {
[17:28:19.740]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:19.740]                 open = "w")
[17:28:19.740]         }
[17:28:19.740]         else {
[17:28:19.740]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:19.740]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:19.740]         }
[17:28:19.740]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:19.740]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:19.740]             base::sink(type = "output", split = FALSE)
[17:28:19.740]             base::close(...future.stdout)
[17:28:19.740]         }, add = TRUE)
[17:28:19.740]     }
[17:28:19.740]     ...future.frame <- base::sys.nframe()
[17:28:19.740]     ...future.conditions <- base::list()
[17:28:19.740]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:19.740]     if (FALSE) {
[17:28:19.740]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:19.740]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:19.740]     }
[17:28:19.740]     ...future.result <- base::tryCatch({
[17:28:19.740]         base::withCallingHandlers({
[17:28:19.740]             ...future.value <- base::withVisible(base::local({
[17:28:19.740]                 ...future.makeSendCondition <- base::local({
[17:28:19.740]                   sendCondition <- NULL
[17:28:19.740]                   function(frame = 1L) {
[17:28:19.740]                     if (is.function(sendCondition)) 
[17:28:19.740]                       return(sendCondition)
[17:28:19.740]                     ns <- getNamespace("parallel")
[17:28:19.740]                     if (exists("sendData", mode = "function", 
[17:28:19.740]                       envir = ns)) {
[17:28:19.740]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:19.740]                         envir = ns)
[17:28:19.740]                       envir <- sys.frame(frame)
[17:28:19.740]                       master <- NULL
[17:28:19.740]                       while (!identical(envir, .GlobalEnv) && 
[17:28:19.740]                         !identical(envir, emptyenv())) {
[17:28:19.740]                         if (exists("master", mode = "list", envir = envir, 
[17:28:19.740]                           inherits = FALSE)) {
[17:28:19.740]                           master <- get("master", mode = "list", 
[17:28:19.740]                             envir = envir, inherits = FALSE)
[17:28:19.740]                           if (inherits(master, c("SOCKnode", 
[17:28:19.740]                             "SOCK0node"))) {
[17:28:19.740]                             sendCondition <<- function(cond) {
[17:28:19.740]                               data <- list(type = "VALUE", value = cond, 
[17:28:19.740]                                 success = TRUE)
[17:28:19.740]                               parallel_sendData(master, data)
[17:28:19.740]                             }
[17:28:19.740]                             return(sendCondition)
[17:28:19.740]                           }
[17:28:19.740]                         }
[17:28:19.740]                         frame <- frame + 1L
[17:28:19.740]                         envir <- sys.frame(frame)
[17:28:19.740]                       }
[17:28:19.740]                     }
[17:28:19.740]                     sendCondition <<- function(cond) NULL
[17:28:19.740]                   }
[17:28:19.740]                 })
[17:28:19.740]                 withCallingHandlers({
[17:28:19.740]                   {
[17:28:19.740]                     sample(x, size = 1L)
[17:28:19.740]                   }
[17:28:19.740]                 }, immediateCondition = function(cond) {
[17:28:19.740]                   sendCondition <- ...future.makeSendCondition()
[17:28:19.740]                   sendCondition(cond)
[17:28:19.740]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.740]                   {
[17:28:19.740]                     inherits <- base::inherits
[17:28:19.740]                     invokeRestart <- base::invokeRestart
[17:28:19.740]                     is.null <- base::is.null
[17:28:19.740]                     muffled <- FALSE
[17:28:19.740]                     if (inherits(cond, "message")) {
[17:28:19.740]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:19.740]                       if (muffled) 
[17:28:19.740]                         invokeRestart("muffleMessage")
[17:28:19.740]                     }
[17:28:19.740]                     else if (inherits(cond, "warning")) {
[17:28:19.740]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:19.740]                       if (muffled) 
[17:28:19.740]                         invokeRestart("muffleWarning")
[17:28:19.740]                     }
[17:28:19.740]                     else if (inherits(cond, "condition")) {
[17:28:19.740]                       if (!is.null(pattern)) {
[17:28:19.740]                         computeRestarts <- base::computeRestarts
[17:28:19.740]                         grepl <- base::grepl
[17:28:19.740]                         restarts <- computeRestarts(cond)
[17:28:19.740]                         for (restart in restarts) {
[17:28:19.740]                           name <- restart$name
[17:28:19.740]                           if (is.null(name)) 
[17:28:19.740]                             next
[17:28:19.740]                           if (!grepl(pattern, name)) 
[17:28:19.740]                             next
[17:28:19.740]                           invokeRestart(restart)
[17:28:19.740]                           muffled <- TRUE
[17:28:19.740]                           break
[17:28:19.740]                         }
[17:28:19.740]                       }
[17:28:19.740]                     }
[17:28:19.740]                     invisible(muffled)
[17:28:19.740]                   }
[17:28:19.740]                   muffleCondition(cond)
[17:28:19.740]                 })
[17:28:19.740]             }))
[17:28:19.740]             future::FutureResult(value = ...future.value$value, 
[17:28:19.740]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.740]                   ...future.rng), globalenv = if (FALSE) 
[17:28:19.740]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:19.740]                     ...future.globalenv.names))
[17:28:19.740]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:19.740]         }, condition = base::local({
[17:28:19.740]             c <- base::c
[17:28:19.740]             inherits <- base::inherits
[17:28:19.740]             invokeRestart <- base::invokeRestart
[17:28:19.740]             length <- base::length
[17:28:19.740]             list <- base::list
[17:28:19.740]             seq.int <- base::seq.int
[17:28:19.740]             signalCondition <- base::signalCondition
[17:28:19.740]             sys.calls <- base::sys.calls
[17:28:19.740]             `[[` <- base::`[[`
[17:28:19.740]             `+` <- base::`+`
[17:28:19.740]             `<<-` <- base::`<<-`
[17:28:19.740]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:19.740]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:19.740]                   3L)]
[17:28:19.740]             }
[17:28:19.740]             function(cond) {
[17:28:19.740]                 is_error <- inherits(cond, "error")
[17:28:19.740]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:19.740]                   NULL)
[17:28:19.740]                 if (is_error) {
[17:28:19.740]                   sessionInformation <- function() {
[17:28:19.740]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:19.740]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:19.740]                       search = base::search(), system = base::Sys.info())
[17:28:19.740]                   }
[17:28:19.740]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.740]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:19.740]                     cond$call), session = sessionInformation(), 
[17:28:19.740]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:19.740]                   signalCondition(cond)
[17:28:19.740]                 }
[17:28:19.740]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:19.740]                 "immediateCondition"))) {
[17:28:19.740]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:19.740]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.740]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:19.740]                   if (TRUE && !signal) {
[17:28:19.740]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.740]                     {
[17:28:19.740]                       inherits <- base::inherits
[17:28:19.740]                       invokeRestart <- base::invokeRestart
[17:28:19.740]                       is.null <- base::is.null
[17:28:19.740]                       muffled <- FALSE
[17:28:19.740]                       if (inherits(cond, "message")) {
[17:28:19.740]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.740]                         if (muffled) 
[17:28:19.740]                           invokeRestart("muffleMessage")
[17:28:19.740]                       }
[17:28:19.740]                       else if (inherits(cond, "warning")) {
[17:28:19.740]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.740]                         if (muffled) 
[17:28:19.740]                           invokeRestart("muffleWarning")
[17:28:19.740]                       }
[17:28:19.740]                       else if (inherits(cond, "condition")) {
[17:28:19.740]                         if (!is.null(pattern)) {
[17:28:19.740]                           computeRestarts <- base::computeRestarts
[17:28:19.740]                           grepl <- base::grepl
[17:28:19.740]                           restarts <- computeRestarts(cond)
[17:28:19.740]                           for (restart in restarts) {
[17:28:19.740]                             name <- restart$name
[17:28:19.740]                             if (is.null(name)) 
[17:28:19.740]                               next
[17:28:19.740]                             if (!grepl(pattern, name)) 
[17:28:19.740]                               next
[17:28:19.740]                             invokeRestart(restart)
[17:28:19.740]                             muffled <- TRUE
[17:28:19.740]                             break
[17:28:19.740]                           }
[17:28:19.740]                         }
[17:28:19.740]                       }
[17:28:19.740]                       invisible(muffled)
[17:28:19.740]                     }
[17:28:19.740]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.740]                   }
[17:28:19.740]                 }
[17:28:19.740]                 else {
[17:28:19.740]                   if (TRUE) {
[17:28:19.740]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.740]                     {
[17:28:19.740]                       inherits <- base::inherits
[17:28:19.740]                       invokeRestart <- base::invokeRestart
[17:28:19.740]                       is.null <- base::is.null
[17:28:19.740]                       muffled <- FALSE
[17:28:19.740]                       if (inherits(cond, "message")) {
[17:28:19.740]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.740]                         if (muffled) 
[17:28:19.740]                           invokeRestart("muffleMessage")
[17:28:19.740]                       }
[17:28:19.740]                       else if (inherits(cond, "warning")) {
[17:28:19.740]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.740]                         if (muffled) 
[17:28:19.740]                           invokeRestart("muffleWarning")
[17:28:19.740]                       }
[17:28:19.740]                       else if (inherits(cond, "condition")) {
[17:28:19.740]                         if (!is.null(pattern)) {
[17:28:19.740]                           computeRestarts <- base::computeRestarts
[17:28:19.740]                           grepl <- base::grepl
[17:28:19.740]                           restarts <- computeRestarts(cond)
[17:28:19.740]                           for (restart in restarts) {
[17:28:19.740]                             name <- restart$name
[17:28:19.740]                             if (is.null(name)) 
[17:28:19.740]                               next
[17:28:19.740]                             if (!grepl(pattern, name)) 
[17:28:19.740]                               next
[17:28:19.740]                             invokeRestart(restart)
[17:28:19.740]                             muffled <- TRUE
[17:28:19.740]                             break
[17:28:19.740]                           }
[17:28:19.740]                         }
[17:28:19.740]                       }
[17:28:19.740]                       invisible(muffled)
[17:28:19.740]                     }
[17:28:19.740]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.740]                   }
[17:28:19.740]                 }
[17:28:19.740]             }
[17:28:19.740]         }))
[17:28:19.740]     }, error = function(ex) {
[17:28:19.740]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:19.740]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.740]                 ...future.rng), started = ...future.startTime, 
[17:28:19.740]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:19.740]             version = "1.8"), class = "FutureResult")
[17:28:19.740]     }, finally = {
[17:28:19.740]         if (!identical(...future.workdir, getwd())) 
[17:28:19.740]             setwd(...future.workdir)
[17:28:19.740]         {
[17:28:19.740]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:19.740]                 ...future.oldOptions$nwarnings <- NULL
[17:28:19.740]             }
[17:28:19.740]             base::options(...future.oldOptions)
[17:28:19.740]             if (.Platform$OS.type == "windows") {
[17:28:19.740]                 old_names <- names(...future.oldEnvVars)
[17:28:19.740]                 envs <- base::Sys.getenv()
[17:28:19.740]                 names <- names(envs)
[17:28:19.740]                 common <- intersect(names, old_names)
[17:28:19.740]                 added <- setdiff(names, old_names)
[17:28:19.740]                 removed <- setdiff(old_names, names)
[17:28:19.740]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:19.740]                   envs[common]]
[17:28:19.740]                 NAMES <- toupper(changed)
[17:28:19.740]                 args <- list()
[17:28:19.740]                 for (kk in seq_along(NAMES)) {
[17:28:19.740]                   name <- changed[[kk]]
[17:28:19.740]                   NAME <- NAMES[[kk]]
[17:28:19.740]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.740]                     next
[17:28:19.740]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.740]                 }
[17:28:19.740]                 NAMES <- toupper(added)
[17:28:19.740]                 for (kk in seq_along(NAMES)) {
[17:28:19.740]                   name <- added[[kk]]
[17:28:19.740]                   NAME <- NAMES[[kk]]
[17:28:19.740]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.740]                     next
[17:28:19.740]                   args[[name]] <- ""
[17:28:19.740]                 }
[17:28:19.740]                 NAMES <- toupper(removed)
[17:28:19.740]                 for (kk in seq_along(NAMES)) {
[17:28:19.740]                   name <- removed[[kk]]
[17:28:19.740]                   NAME <- NAMES[[kk]]
[17:28:19.740]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.740]                     next
[17:28:19.740]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.740]                 }
[17:28:19.740]                 if (length(args) > 0) 
[17:28:19.740]                   base::do.call(base::Sys.setenv, args = args)
[17:28:19.740]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:19.740]             }
[17:28:19.740]             else {
[17:28:19.740]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:19.740]             }
[17:28:19.740]             {
[17:28:19.740]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:19.740]                   0L) {
[17:28:19.740]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:19.740]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:19.740]                   base::options(opts)
[17:28:19.740]                 }
[17:28:19.740]                 {
[17:28:19.740]                   {
[17:28:19.740]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:19.740]                     NULL
[17:28:19.740]                   }
[17:28:19.740]                   options(future.plan = NULL)
[17:28:19.740]                   if (is.na(NA_character_)) 
[17:28:19.740]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.740]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:19.740]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:19.740]                     .init = FALSE)
[17:28:19.740]                 }
[17:28:19.740]             }
[17:28:19.740]         }
[17:28:19.740]     })
[17:28:19.740]     if (TRUE) {
[17:28:19.740]         base::sink(type = "output", split = FALSE)
[17:28:19.740]         if (TRUE) {
[17:28:19.740]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:19.740]         }
[17:28:19.740]         else {
[17:28:19.740]             ...future.result["stdout"] <- base::list(NULL)
[17:28:19.740]         }
[17:28:19.740]         base::close(...future.stdout)
[17:28:19.740]         ...future.stdout <- NULL
[17:28:19.740]     }
[17:28:19.740]     ...future.result$conditions <- ...future.conditions
[17:28:19.740]     ...future.result$finished <- base::Sys.time()
[17:28:19.740]     ...future.result
[17:28:19.740] }
[17:28:19.746] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:19.746] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:19.746] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:19.747] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:19.747] MultisessionFuture started
[17:28:19.747] - Launch lazy future ... done
[17:28:19.747] run() for 'MultisessionFuture' ... done
[17:28:19.748] getGlobalsAndPackages() ...
[17:28:19.748] Searching for globals...
[17:28:19.749] - globals found: [3] '{', 'sample', 'x'
[17:28:19.749] Searching for globals ... DONE
[17:28:19.749] Resolving globals: FALSE
[17:28:19.750] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:19.750] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:19.751] - globals: [1] 'x'
[17:28:19.751] 
[17:28:19.751] getGlobalsAndPackages() ... DONE
[17:28:19.751] run() for 'Future' ...
[17:28:19.751] - state: 'created'
[17:28:19.752] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:19.765] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:19.765] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:19.765]   - Field: 'node'
[17:28:19.766]   - Field: 'label'
[17:28:19.766]   - Field: 'local'
[17:28:19.766]   - Field: 'owner'
[17:28:19.766]   - Field: 'envir'
[17:28:19.766]   - Field: 'workers'
[17:28:19.766]   - Field: 'packages'
[17:28:19.767]   - Field: 'gc'
[17:28:19.767]   - Field: 'conditions'
[17:28:19.767]   - Field: 'persistent'
[17:28:19.767]   - Field: 'expr'
[17:28:19.767]   - Field: 'uuid'
[17:28:19.768]   - Field: 'seed'
[17:28:19.768]   - Field: 'version'
[17:28:19.768]   - Field: 'result'
[17:28:19.768]   - Field: 'asynchronous'
[17:28:19.768]   - Field: 'calls'
[17:28:19.768]   - Field: 'globals'
[17:28:19.769]   - Field: 'stdout'
[17:28:19.769]   - Field: 'earlySignal'
[17:28:19.769]   - Field: 'lazy'
[17:28:19.769]   - Field: 'state'
[17:28:19.769] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:19.769] - Launch lazy future ...
[17:28:19.770] Packages needed by the future expression (n = 0): <none>
[17:28:19.770] Packages needed by future strategies (n = 0): <none>
[17:28:19.771] {
[17:28:19.771]     {
[17:28:19.771]         {
[17:28:19.771]             ...future.startTime <- base::Sys.time()
[17:28:19.771]             {
[17:28:19.771]                 {
[17:28:19.771]                   {
[17:28:19.771]                     {
[17:28:19.771]                       {
[17:28:19.771]                         base::local({
[17:28:19.771]                           has_future <- base::requireNamespace("future", 
[17:28:19.771]                             quietly = TRUE)
[17:28:19.771]                           if (has_future) {
[17:28:19.771]                             ns <- base::getNamespace("future")
[17:28:19.771]                             version <- ns[[".package"]][["version"]]
[17:28:19.771]                             if (is.null(version)) 
[17:28:19.771]                               version <- utils::packageVersion("future")
[17:28:19.771]                           }
[17:28:19.771]                           else {
[17:28:19.771]                             version <- NULL
[17:28:19.771]                           }
[17:28:19.771]                           if (!has_future || version < "1.8.0") {
[17:28:19.771]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:19.771]                               "", base::R.version$version.string), 
[17:28:19.771]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:19.771]                                 base::R.version$platform, 8 * 
[17:28:19.771]                                   base::.Machine$sizeof.pointer), 
[17:28:19.771]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:19.771]                                 "release", "version")], collapse = " "), 
[17:28:19.771]                               hostname = base::Sys.info()[["nodename"]])
[17:28:19.771]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:19.771]                               info)
[17:28:19.771]                             info <- base::paste(info, collapse = "; ")
[17:28:19.771]                             if (!has_future) {
[17:28:19.771]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:19.771]                                 info)
[17:28:19.771]                             }
[17:28:19.771]                             else {
[17:28:19.771]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:19.771]                                 info, version)
[17:28:19.771]                             }
[17:28:19.771]                             base::stop(msg)
[17:28:19.771]                           }
[17:28:19.771]                         })
[17:28:19.771]                       }
[17:28:19.771]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:19.771]                       base::options(mc.cores = 1L)
[17:28:19.771]                     }
[17:28:19.771]                     ...future.strategy.old <- future::plan("list")
[17:28:19.771]                     options(future.plan = NULL)
[17:28:19.771]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.771]                     future::plan("default", .cleanup = FALSE, 
[17:28:19.771]                       .init = FALSE)
[17:28:19.771]                   }
[17:28:19.771]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:28:19.771]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:28:19.771]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:28:19.771]                 }
[17:28:19.771]                 ...future.workdir <- getwd()
[17:28:19.771]             }
[17:28:19.771]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:19.771]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:19.771]         }
[17:28:19.771]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:19.771]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:19.771]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:19.771]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:19.771]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:19.771]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:19.771]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:19.771]             base::names(...future.oldOptions))
[17:28:19.771]     }
[17:28:19.771]     if (FALSE) {
[17:28:19.771]     }
[17:28:19.771]     else {
[17:28:19.771]         if (TRUE) {
[17:28:19.771]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:19.771]                 open = "w")
[17:28:19.771]         }
[17:28:19.771]         else {
[17:28:19.771]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:19.771]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:19.771]         }
[17:28:19.771]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:19.771]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:19.771]             base::sink(type = "output", split = FALSE)
[17:28:19.771]             base::close(...future.stdout)
[17:28:19.771]         }, add = TRUE)
[17:28:19.771]     }
[17:28:19.771]     ...future.frame <- base::sys.nframe()
[17:28:19.771]     ...future.conditions <- base::list()
[17:28:19.771]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:19.771]     if (FALSE) {
[17:28:19.771]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:19.771]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:19.771]     }
[17:28:19.771]     ...future.result <- base::tryCatch({
[17:28:19.771]         base::withCallingHandlers({
[17:28:19.771]             ...future.value <- base::withVisible(base::local({
[17:28:19.771]                 ...future.makeSendCondition <- base::local({
[17:28:19.771]                   sendCondition <- NULL
[17:28:19.771]                   function(frame = 1L) {
[17:28:19.771]                     if (is.function(sendCondition)) 
[17:28:19.771]                       return(sendCondition)
[17:28:19.771]                     ns <- getNamespace("parallel")
[17:28:19.771]                     if (exists("sendData", mode = "function", 
[17:28:19.771]                       envir = ns)) {
[17:28:19.771]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:19.771]                         envir = ns)
[17:28:19.771]                       envir <- sys.frame(frame)
[17:28:19.771]                       master <- NULL
[17:28:19.771]                       while (!identical(envir, .GlobalEnv) && 
[17:28:19.771]                         !identical(envir, emptyenv())) {
[17:28:19.771]                         if (exists("master", mode = "list", envir = envir, 
[17:28:19.771]                           inherits = FALSE)) {
[17:28:19.771]                           master <- get("master", mode = "list", 
[17:28:19.771]                             envir = envir, inherits = FALSE)
[17:28:19.771]                           if (inherits(master, c("SOCKnode", 
[17:28:19.771]                             "SOCK0node"))) {
[17:28:19.771]                             sendCondition <<- function(cond) {
[17:28:19.771]                               data <- list(type = "VALUE", value = cond, 
[17:28:19.771]                                 success = TRUE)
[17:28:19.771]                               parallel_sendData(master, data)
[17:28:19.771]                             }
[17:28:19.771]                             return(sendCondition)
[17:28:19.771]                           }
[17:28:19.771]                         }
[17:28:19.771]                         frame <- frame + 1L
[17:28:19.771]                         envir <- sys.frame(frame)
[17:28:19.771]                       }
[17:28:19.771]                     }
[17:28:19.771]                     sendCondition <<- function(cond) NULL
[17:28:19.771]                   }
[17:28:19.771]                 })
[17:28:19.771]                 withCallingHandlers({
[17:28:19.771]                   {
[17:28:19.771]                     sample(x, size = 1L)
[17:28:19.771]                   }
[17:28:19.771]                 }, immediateCondition = function(cond) {
[17:28:19.771]                   sendCondition <- ...future.makeSendCondition()
[17:28:19.771]                   sendCondition(cond)
[17:28:19.771]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.771]                   {
[17:28:19.771]                     inherits <- base::inherits
[17:28:19.771]                     invokeRestart <- base::invokeRestart
[17:28:19.771]                     is.null <- base::is.null
[17:28:19.771]                     muffled <- FALSE
[17:28:19.771]                     if (inherits(cond, "message")) {
[17:28:19.771]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:19.771]                       if (muffled) 
[17:28:19.771]                         invokeRestart("muffleMessage")
[17:28:19.771]                     }
[17:28:19.771]                     else if (inherits(cond, "warning")) {
[17:28:19.771]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:19.771]                       if (muffled) 
[17:28:19.771]                         invokeRestart("muffleWarning")
[17:28:19.771]                     }
[17:28:19.771]                     else if (inherits(cond, "condition")) {
[17:28:19.771]                       if (!is.null(pattern)) {
[17:28:19.771]                         computeRestarts <- base::computeRestarts
[17:28:19.771]                         grepl <- base::grepl
[17:28:19.771]                         restarts <- computeRestarts(cond)
[17:28:19.771]                         for (restart in restarts) {
[17:28:19.771]                           name <- restart$name
[17:28:19.771]                           if (is.null(name)) 
[17:28:19.771]                             next
[17:28:19.771]                           if (!grepl(pattern, name)) 
[17:28:19.771]                             next
[17:28:19.771]                           invokeRestart(restart)
[17:28:19.771]                           muffled <- TRUE
[17:28:19.771]                           break
[17:28:19.771]                         }
[17:28:19.771]                       }
[17:28:19.771]                     }
[17:28:19.771]                     invisible(muffled)
[17:28:19.771]                   }
[17:28:19.771]                   muffleCondition(cond)
[17:28:19.771]                 })
[17:28:19.771]             }))
[17:28:19.771]             future::FutureResult(value = ...future.value$value, 
[17:28:19.771]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.771]                   ...future.rng), globalenv = if (FALSE) 
[17:28:19.771]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:19.771]                     ...future.globalenv.names))
[17:28:19.771]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:19.771]         }, condition = base::local({
[17:28:19.771]             c <- base::c
[17:28:19.771]             inherits <- base::inherits
[17:28:19.771]             invokeRestart <- base::invokeRestart
[17:28:19.771]             length <- base::length
[17:28:19.771]             list <- base::list
[17:28:19.771]             seq.int <- base::seq.int
[17:28:19.771]             signalCondition <- base::signalCondition
[17:28:19.771]             sys.calls <- base::sys.calls
[17:28:19.771]             `[[` <- base::`[[`
[17:28:19.771]             `+` <- base::`+`
[17:28:19.771]             `<<-` <- base::`<<-`
[17:28:19.771]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:19.771]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:19.771]                   3L)]
[17:28:19.771]             }
[17:28:19.771]             function(cond) {
[17:28:19.771]                 is_error <- inherits(cond, "error")
[17:28:19.771]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:19.771]                   NULL)
[17:28:19.771]                 if (is_error) {
[17:28:19.771]                   sessionInformation <- function() {
[17:28:19.771]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:19.771]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:19.771]                       search = base::search(), system = base::Sys.info())
[17:28:19.771]                   }
[17:28:19.771]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.771]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:19.771]                     cond$call), session = sessionInformation(), 
[17:28:19.771]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:19.771]                   signalCondition(cond)
[17:28:19.771]                 }
[17:28:19.771]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:19.771]                 "immediateCondition"))) {
[17:28:19.771]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:19.771]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.771]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:19.771]                   if (TRUE && !signal) {
[17:28:19.771]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.771]                     {
[17:28:19.771]                       inherits <- base::inherits
[17:28:19.771]                       invokeRestart <- base::invokeRestart
[17:28:19.771]                       is.null <- base::is.null
[17:28:19.771]                       muffled <- FALSE
[17:28:19.771]                       if (inherits(cond, "message")) {
[17:28:19.771]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.771]                         if (muffled) 
[17:28:19.771]                           invokeRestart("muffleMessage")
[17:28:19.771]                       }
[17:28:19.771]                       else if (inherits(cond, "warning")) {
[17:28:19.771]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.771]                         if (muffled) 
[17:28:19.771]                           invokeRestart("muffleWarning")
[17:28:19.771]                       }
[17:28:19.771]                       else if (inherits(cond, "condition")) {
[17:28:19.771]                         if (!is.null(pattern)) {
[17:28:19.771]                           computeRestarts <- base::computeRestarts
[17:28:19.771]                           grepl <- base::grepl
[17:28:19.771]                           restarts <- computeRestarts(cond)
[17:28:19.771]                           for (restart in restarts) {
[17:28:19.771]                             name <- restart$name
[17:28:19.771]                             if (is.null(name)) 
[17:28:19.771]                               next
[17:28:19.771]                             if (!grepl(pattern, name)) 
[17:28:19.771]                               next
[17:28:19.771]                             invokeRestart(restart)
[17:28:19.771]                             muffled <- TRUE
[17:28:19.771]                             break
[17:28:19.771]                           }
[17:28:19.771]                         }
[17:28:19.771]                       }
[17:28:19.771]                       invisible(muffled)
[17:28:19.771]                     }
[17:28:19.771]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.771]                   }
[17:28:19.771]                 }
[17:28:19.771]                 else {
[17:28:19.771]                   if (TRUE) {
[17:28:19.771]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.771]                     {
[17:28:19.771]                       inherits <- base::inherits
[17:28:19.771]                       invokeRestart <- base::invokeRestart
[17:28:19.771]                       is.null <- base::is.null
[17:28:19.771]                       muffled <- FALSE
[17:28:19.771]                       if (inherits(cond, "message")) {
[17:28:19.771]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.771]                         if (muffled) 
[17:28:19.771]                           invokeRestart("muffleMessage")
[17:28:19.771]                       }
[17:28:19.771]                       else if (inherits(cond, "warning")) {
[17:28:19.771]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.771]                         if (muffled) 
[17:28:19.771]                           invokeRestart("muffleWarning")
[17:28:19.771]                       }
[17:28:19.771]                       else if (inherits(cond, "condition")) {
[17:28:19.771]                         if (!is.null(pattern)) {
[17:28:19.771]                           computeRestarts <- base::computeRestarts
[17:28:19.771]                           grepl <- base::grepl
[17:28:19.771]                           restarts <- computeRestarts(cond)
[17:28:19.771]                           for (restart in restarts) {
[17:28:19.771]                             name <- restart$name
[17:28:19.771]                             if (is.null(name)) 
[17:28:19.771]                               next
[17:28:19.771]                             if (!grepl(pattern, name)) 
[17:28:19.771]                               next
[17:28:19.771]                             invokeRestart(restart)
[17:28:19.771]                             muffled <- TRUE
[17:28:19.771]                             break
[17:28:19.771]                           }
[17:28:19.771]                         }
[17:28:19.771]                       }
[17:28:19.771]                       invisible(muffled)
[17:28:19.771]                     }
[17:28:19.771]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.771]                   }
[17:28:19.771]                 }
[17:28:19.771]             }
[17:28:19.771]         }))
[17:28:19.771]     }, error = function(ex) {
[17:28:19.771]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:19.771]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.771]                 ...future.rng), started = ...future.startTime, 
[17:28:19.771]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:19.771]             version = "1.8"), class = "FutureResult")
[17:28:19.771]     }, finally = {
[17:28:19.771]         if (!identical(...future.workdir, getwd())) 
[17:28:19.771]             setwd(...future.workdir)
[17:28:19.771]         {
[17:28:19.771]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:19.771]                 ...future.oldOptions$nwarnings <- NULL
[17:28:19.771]             }
[17:28:19.771]             base::options(...future.oldOptions)
[17:28:19.771]             if (.Platform$OS.type == "windows") {
[17:28:19.771]                 old_names <- names(...future.oldEnvVars)
[17:28:19.771]                 envs <- base::Sys.getenv()
[17:28:19.771]                 names <- names(envs)
[17:28:19.771]                 common <- intersect(names, old_names)
[17:28:19.771]                 added <- setdiff(names, old_names)
[17:28:19.771]                 removed <- setdiff(old_names, names)
[17:28:19.771]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:19.771]                   envs[common]]
[17:28:19.771]                 NAMES <- toupper(changed)
[17:28:19.771]                 args <- list()
[17:28:19.771]                 for (kk in seq_along(NAMES)) {
[17:28:19.771]                   name <- changed[[kk]]
[17:28:19.771]                   NAME <- NAMES[[kk]]
[17:28:19.771]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.771]                     next
[17:28:19.771]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.771]                 }
[17:28:19.771]                 NAMES <- toupper(added)
[17:28:19.771]                 for (kk in seq_along(NAMES)) {
[17:28:19.771]                   name <- added[[kk]]
[17:28:19.771]                   NAME <- NAMES[[kk]]
[17:28:19.771]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.771]                     next
[17:28:19.771]                   args[[name]] <- ""
[17:28:19.771]                 }
[17:28:19.771]                 NAMES <- toupper(removed)
[17:28:19.771]                 for (kk in seq_along(NAMES)) {
[17:28:19.771]                   name <- removed[[kk]]
[17:28:19.771]                   NAME <- NAMES[[kk]]
[17:28:19.771]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.771]                     next
[17:28:19.771]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.771]                 }
[17:28:19.771]                 if (length(args) > 0) 
[17:28:19.771]                   base::do.call(base::Sys.setenv, args = args)
[17:28:19.771]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:19.771]             }
[17:28:19.771]             else {
[17:28:19.771]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:19.771]             }
[17:28:19.771]             {
[17:28:19.771]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:19.771]                   0L) {
[17:28:19.771]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:19.771]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:19.771]                   base::options(opts)
[17:28:19.771]                 }
[17:28:19.771]                 {
[17:28:19.771]                   {
[17:28:19.771]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:19.771]                     NULL
[17:28:19.771]                   }
[17:28:19.771]                   options(future.plan = NULL)
[17:28:19.771]                   if (is.na(NA_character_)) 
[17:28:19.771]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.771]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:19.771]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:19.771]                     .init = FALSE)
[17:28:19.771]                 }
[17:28:19.771]             }
[17:28:19.771]         }
[17:28:19.771]     })
[17:28:19.771]     if (TRUE) {
[17:28:19.771]         base::sink(type = "output", split = FALSE)
[17:28:19.771]         if (TRUE) {
[17:28:19.771]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:19.771]         }
[17:28:19.771]         else {
[17:28:19.771]             ...future.result["stdout"] <- base::list(NULL)
[17:28:19.771]         }
[17:28:19.771]         base::close(...future.stdout)
[17:28:19.771]         ...future.stdout <- NULL
[17:28:19.771]     }
[17:28:19.771]     ...future.result$conditions <- ...future.conditions
[17:28:19.771]     ...future.result$finished <- base::Sys.time()
[17:28:19.771]     ...future.result
[17:28:19.771] }
[17:28:19.775] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:19.796] receiveMessageFromWorker() for ClusterFuture ...
[17:28:19.796] - Validating connection of MultisessionFuture
[17:28:19.796] - received message: FutureResult
[17:28:19.797] - Received FutureResult
[17:28:19.797] - Erased future from FutureRegistry
[17:28:19.797] result() for ClusterFuture ...
[17:28:19.797] - result already collected: FutureResult
[17:28:19.797] result() for ClusterFuture ... done
[17:28:19.797] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:19.798] result() for ClusterFuture ...
[17:28:19.798] - result already collected: FutureResult
[17:28:19.798] result() for ClusterFuture ... done
[17:28:19.798] result() for ClusterFuture ...
[17:28:19.798] - result already collected: FutureResult
[17:28:19.798] result() for ClusterFuture ... done
[17:28:19.799] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:19.799] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:19.800] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:19.800] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:19.801] MultisessionFuture started
[17:28:19.801] - Launch lazy future ... done
[17:28:19.801] run() for 'MultisessionFuture' ... done
[17:28:19.801] getGlobalsAndPackages() ...
[17:28:19.801] Searching for globals...
[17:28:19.802] - globals found: [3] '{', 'sample', 'x'
[17:28:19.803] Searching for globals ... DONE
[17:28:19.803] Resolving globals: FALSE
[17:28:19.803] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:19.804] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:19.804] - globals: [1] 'x'
[17:28:19.804] 
[17:28:19.804] getGlobalsAndPackages() ... DONE
[17:28:19.806] run() for 'Future' ...
[17:28:19.807] - state: 'created'
[17:28:19.807] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:19.820] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:19.821] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:19.821]   - Field: 'node'
[17:28:19.821]   - Field: 'label'
[17:28:19.821]   - Field: 'local'
[17:28:19.821]   - Field: 'owner'
[17:28:19.822]   - Field: 'envir'
[17:28:19.822]   - Field: 'workers'
[17:28:19.822]   - Field: 'packages'
[17:28:19.822]   - Field: 'gc'
[17:28:19.822]   - Field: 'conditions'
[17:28:19.822]   - Field: 'persistent'
[17:28:19.823]   - Field: 'expr'
[17:28:19.823]   - Field: 'uuid'
[17:28:19.823]   - Field: 'seed'
[17:28:19.823]   - Field: 'version'
[17:28:19.823]   - Field: 'result'
[17:28:19.824]   - Field: 'asynchronous'
[17:28:19.824]   - Field: 'calls'
[17:28:19.824]   - Field: 'globals'
[17:28:19.824]   - Field: 'stdout'
[17:28:19.824]   - Field: 'earlySignal'
[17:28:19.824]   - Field: 'lazy'
[17:28:19.825]   - Field: 'state'
[17:28:19.825] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:19.825] - Launch lazy future ...
[17:28:19.825] Packages needed by the future expression (n = 0): <none>
[17:28:19.825] Packages needed by future strategies (n = 0): <none>
[17:28:19.826] {
[17:28:19.826]     {
[17:28:19.826]         {
[17:28:19.826]             ...future.startTime <- base::Sys.time()
[17:28:19.826]             {
[17:28:19.826]                 {
[17:28:19.826]                   {
[17:28:19.826]                     {
[17:28:19.826]                       {
[17:28:19.826]                         base::local({
[17:28:19.826]                           has_future <- base::requireNamespace("future", 
[17:28:19.826]                             quietly = TRUE)
[17:28:19.826]                           if (has_future) {
[17:28:19.826]                             ns <- base::getNamespace("future")
[17:28:19.826]                             version <- ns[[".package"]][["version"]]
[17:28:19.826]                             if (is.null(version)) 
[17:28:19.826]                               version <- utils::packageVersion("future")
[17:28:19.826]                           }
[17:28:19.826]                           else {
[17:28:19.826]                             version <- NULL
[17:28:19.826]                           }
[17:28:19.826]                           if (!has_future || version < "1.8.0") {
[17:28:19.826]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:19.826]                               "", base::R.version$version.string), 
[17:28:19.826]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:19.826]                                 base::R.version$platform, 8 * 
[17:28:19.826]                                   base::.Machine$sizeof.pointer), 
[17:28:19.826]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:19.826]                                 "release", "version")], collapse = " "), 
[17:28:19.826]                               hostname = base::Sys.info()[["nodename"]])
[17:28:19.826]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:19.826]                               info)
[17:28:19.826]                             info <- base::paste(info, collapse = "; ")
[17:28:19.826]                             if (!has_future) {
[17:28:19.826]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:19.826]                                 info)
[17:28:19.826]                             }
[17:28:19.826]                             else {
[17:28:19.826]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:19.826]                                 info, version)
[17:28:19.826]                             }
[17:28:19.826]                             base::stop(msg)
[17:28:19.826]                           }
[17:28:19.826]                         })
[17:28:19.826]                       }
[17:28:19.826]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:19.826]                       base::options(mc.cores = 1L)
[17:28:19.826]                     }
[17:28:19.826]                     ...future.strategy.old <- future::plan("list")
[17:28:19.826]                     options(future.plan = NULL)
[17:28:19.826]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.826]                     future::plan("default", .cleanup = FALSE, 
[17:28:19.826]                       .init = FALSE)
[17:28:19.826]                   }
[17:28:19.826]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:28:19.826]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:28:19.826]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:28:19.826]                 }
[17:28:19.826]                 ...future.workdir <- getwd()
[17:28:19.826]             }
[17:28:19.826]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:19.826]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:19.826]         }
[17:28:19.826]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:19.826]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:19.826]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:19.826]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:19.826]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:19.826]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:19.826]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:19.826]             base::names(...future.oldOptions))
[17:28:19.826]     }
[17:28:19.826]     if (FALSE) {
[17:28:19.826]     }
[17:28:19.826]     else {
[17:28:19.826]         if (TRUE) {
[17:28:19.826]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:19.826]                 open = "w")
[17:28:19.826]         }
[17:28:19.826]         else {
[17:28:19.826]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:19.826]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:19.826]         }
[17:28:19.826]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:19.826]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:19.826]             base::sink(type = "output", split = FALSE)
[17:28:19.826]             base::close(...future.stdout)
[17:28:19.826]         }, add = TRUE)
[17:28:19.826]     }
[17:28:19.826]     ...future.frame <- base::sys.nframe()
[17:28:19.826]     ...future.conditions <- base::list()
[17:28:19.826]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:19.826]     if (FALSE) {
[17:28:19.826]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:19.826]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:19.826]     }
[17:28:19.826]     ...future.result <- base::tryCatch({
[17:28:19.826]         base::withCallingHandlers({
[17:28:19.826]             ...future.value <- base::withVisible(base::local({
[17:28:19.826]                 ...future.makeSendCondition <- base::local({
[17:28:19.826]                   sendCondition <- NULL
[17:28:19.826]                   function(frame = 1L) {
[17:28:19.826]                     if (is.function(sendCondition)) 
[17:28:19.826]                       return(sendCondition)
[17:28:19.826]                     ns <- getNamespace("parallel")
[17:28:19.826]                     if (exists("sendData", mode = "function", 
[17:28:19.826]                       envir = ns)) {
[17:28:19.826]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:19.826]                         envir = ns)
[17:28:19.826]                       envir <- sys.frame(frame)
[17:28:19.826]                       master <- NULL
[17:28:19.826]                       while (!identical(envir, .GlobalEnv) && 
[17:28:19.826]                         !identical(envir, emptyenv())) {
[17:28:19.826]                         if (exists("master", mode = "list", envir = envir, 
[17:28:19.826]                           inherits = FALSE)) {
[17:28:19.826]                           master <- get("master", mode = "list", 
[17:28:19.826]                             envir = envir, inherits = FALSE)
[17:28:19.826]                           if (inherits(master, c("SOCKnode", 
[17:28:19.826]                             "SOCK0node"))) {
[17:28:19.826]                             sendCondition <<- function(cond) {
[17:28:19.826]                               data <- list(type = "VALUE", value = cond, 
[17:28:19.826]                                 success = TRUE)
[17:28:19.826]                               parallel_sendData(master, data)
[17:28:19.826]                             }
[17:28:19.826]                             return(sendCondition)
[17:28:19.826]                           }
[17:28:19.826]                         }
[17:28:19.826]                         frame <- frame + 1L
[17:28:19.826]                         envir <- sys.frame(frame)
[17:28:19.826]                       }
[17:28:19.826]                     }
[17:28:19.826]                     sendCondition <<- function(cond) NULL
[17:28:19.826]                   }
[17:28:19.826]                 })
[17:28:19.826]                 withCallingHandlers({
[17:28:19.826]                   {
[17:28:19.826]                     sample(x, size = 1L)
[17:28:19.826]                   }
[17:28:19.826]                 }, immediateCondition = function(cond) {
[17:28:19.826]                   sendCondition <- ...future.makeSendCondition()
[17:28:19.826]                   sendCondition(cond)
[17:28:19.826]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.826]                   {
[17:28:19.826]                     inherits <- base::inherits
[17:28:19.826]                     invokeRestart <- base::invokeRestart
[17:28:19.826]                     is.null <- base::is.null
[17:28:19.826]                     muffled <- FALSE
[17:28:19.826]                     if (inherits(cond, "message")) {
[17:28:19.826]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:19.826]                       if (muffled) 
[17:28:19.826]                         invokeRestart("muffleMessage")
[17:28:19.826]                     }
[17:28:19.826]                     else if (inherits(cond, "warning")) {
[17:28:19.826]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:19.826]                       if (muffled) 
[17:28:19.826]                         invokeRestart("muffleWarning")
[17:28:19.826]                     }
[17:28:19.826]                     else if (inherits(cond, "condition")) {
[17:28:19.826]                       if (!is.null(pattern)) {
[17:28:19.826]                         computeRestarts <- base::computeRestarts
[17:28:19.826]                         grepl <- base::grepl
[17:28:19.826]                         restarts <- computeRestarts(cond)
[17:28:19.826]                         for (restart in restarts) {
[17:28:19.826]                           name <- restart$name
[17:28:19.826]                           if (is.null(name)) 
[17:28:19.826]                             next
[17:28:19.826]                           if (!grepl(pattern, name)) 
[17:28:19.826]                             next
[17:28:19.826]                           invokeRestart(restart)
[17:28:19.826]                           muffled <- TRUE
[17:28:19.826]                           break
[17:28:19.826]                         }
[17:28:19.826]                       }
[17:28:19.826]                     }
[17:28:19.826]                     invisible(muffled)
[17:28:19.826]                   }
[17:28:19.826]                   muffleCondition(cond)
[17:28:19.826]                 })
[17:28:19.826]             }))
[17:28:19.826]             future::FutureResult(value = ...future.value$value, 
[17:28:19.826]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.826]                   ...future.rng), globalenv = if (FALSE) 
[17:28:19.826]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:19.826]                     ...future.globalenv.names))
[17:28:19.826]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:19.826]         }, condition = base::local({
[17:28:19.826]             c <- base::c
[17:28:19.826]             inherits <- base::inherits
[17:28:19.826]             invokeRestart <- base::invokeRestart
[17:28:19.826]             length <- base::length
[17:28:19.826]             list <- base::list
[17:28:19.826]             seq.int <- base::seq.int
[17:28:19.826]             signalCondition <- base::signalCondition
[17:28:19.826]             sys.calls <- base::sys.calls
[17:28:19.826]             `[[` <- base::`[[`
[17:28:19.826]             `+` <- base::`+`
[17:28:19.826]             `<<-` <- base::`<<-`
[17:28:19.826]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:19.826]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:19.826]                   3L)]
[17:28:19.826]             }
[17:28:19.826]             function(cond) {
[17:28:19.826]                 is_error <- inherits(cond, "error")
[17:28:19.826]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:19.826]                   NULL)
[17:28:19.826]                 if (is_error) {
[17:28:19.826]                   sessionInformation <- function() {
[17:28:19.826]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:19.826]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:19.826]                       search = base::search(), system = base::Sys.info())
[17:28:19.826]                   }
[17:28:19.826]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.826]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:19.826]                     cond$call), session = sessionInformation(), 
[17:28:19.826]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:19.826]                   signalCondition(cond)
[17:28:19.826]                 }
[17:28:19.826]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:19.826]                 "immediateCondition"))) {
[17:28:19.826]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:19.826]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.826]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:19.826]                   if (TRUE && !signal) {
[17:28:19.826]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.826]                     {
[17:28:19.826]                       inherits <- base::inherits
[17:28:19.826]                       invokeRestart <- base::invokeRestart
[17:28:19.826]                       is.null <- base::is.null
[17:28:19.826]                       muffled <- FALSE
[17:28:19.826]                       if (inherits(cond, "message")) {
[17:28:19.826]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.826]                         if (muffled) 
[17:28:19.826]                           invokeRestart("muffleMessage")
[17:28:19.826]                       }
[17:28:19.826]                       else if (inherits(cond, "warning")) {
[17:28:19.826]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.826]                         if (muffled) 
[17:28:19.826]                           invokeRestart("muffleWarning")
[17:28:19.826]                       }
[17:28:19.826]                       else if (inherits(cond, "condition")) {
[17:28:19.826]                         if (!is.null(pattern)) {
[17:28:19.826]                           computeRestarts <- base::computeRestarts
[17:28:19.826]                           grepl <- base::grepl
[17:28:19.826]                           restarts <- computeRestarts(cond)
[17:28:19.826]                           for (restart in restarts) {
[17:28:19.826]                             name <- restart$name
[17:28:19.826]                             if (is.null(name)) 
[17:28:19.826]                               next
[17:28:19.826]                             if (!grepl(pattern, name)) 
[17:28:19.826]                               next
[17:28:19.826]                             invokeRestart(restart)
[17:28:19.826]                             muffled <- TRUE
[17:28:19.826]                             break
[17:28:19.826]                           }
[17:28:19.826]                         }
[17:28:19.826]                       }
[17:28:19.826]                       invisible(muffled)
[17:28:19.826]                     }
[17:28:19.826]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.826]                   }
[17:28:19.826]                 }
[17:28:19.826]                 else {
[17:28:19.826]                   if (TRUE) {
[17:28:19.826]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.826]                     {
[17:28:19.826]                       inherits <- base::inherits
[17:28:19.826]                       invokeRestart <- base::invokeRestart
[17:28:19.826]                       is.null <- base::is.null
[17:28:19.826]                       muffled <- FALSE
[17:28:19.826]                       if (inherits(cond, "message")) {
[17:28:19.826]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.826]                         if (muffled) 
[17:28:19.826]                           invokeRestart("muffleMessage")
[17:28:19.826]                       }
[17:28:19.826]                       else if (inherits(cond, "warning")) {
[17:28:19.826]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.826]                         if (muffled) 
[17:28:19.826]                           invokeRestart("muffleWarning")
[17:28:19.826]                       }
[17:28:19.826]                       else if (inherits(cond, "condition")) {
[17:28:19.826]                         if (!is.null(pattern)) {
[17:28:19.826]                           computeRestarts <- base::computeRestarts
[17:28:19.826]                           grepl <- base::grepl
[17:28:19.826]                           restarts <- computeRestarts(cond)
[17:28:19.826]                           for (restart in restarts) {
[17:28:19.826]                             name <- restart$name
[17:28:19.826]                             if (is.null(name)) 
[17:28:19.826]                               next
[17:28:19.826]                             if (!grepl(pattern, name)) 
[17:28:19.826]                               next
[17:28:19.826]                             invokeRestart(restart)
[17:28:19.826]                             muffled <- TRUE
[17:28:19.826]                             break
[17:28:19.826]                           }
[17:28:19.826]                         }
[17:28:19.826]                       }
[17:28:19.826]                       invisible(muffled)
[17:28:19.826]                     }
[17:28:19.826]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.826]                   }
[17:28:19.826]                 }
[17:28:19.826]             }
[17:28:19.826]         }))
[17:28:19.826]     }, error = function(ex) {
[17:28:19.826]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:19.826]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.826]                 ...future.rng), started = ...future.startTime, 
[17:28:19.826]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:19.826]             version = "1.8"), class = "FutureResult")
[17:28:19.826]     }, finally = {
[17:28:19.826]         if (!identical(...future.workdir, getwd())) 
[17:28:19.826]             setwd(...future.workdir)
[17:28:19.826]         {
[17:28:19.826]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:19.826]                 ...future.oldOptions$nwarnings <- NULL
[17:28:19.826]             }
[17:28:19.826]             base::options(...future.oldOptions)
[17:28:19.826]             if (.Platform$OS.type == "windows") {
[17:28:19.826]                 old_names <- names(...future.oldEnvVars)
[17:28:19.826]                 envs <- base::Sys.getenv()
[17:28:19.826]                 names <- names(envs)
[17:28:19.826]                 common <- intersect(names, old_names)
[17:28:19.826]                 added <- setdiff(names, old_names)
[17:28:19.826]                 removed <- setdiff(old_names, names)
[17:28:19.826]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:19.826]                   envs[common]]
[17:28:19.826]                 NAMES <- toupper(changed)
[17:28:19.826]                 args <- list()
[17:28:19.826]                 for (kk in seq_along(NAMES)) {
[17:28:19.826]                   name <- changed[[kk]]
[17:28:19.826]                   NAME <- NAMES[[kk]]
[17:28:19.826]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.826]                     next
[17:28:19.826]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.826]                 }
[17:28:19.826]                 NAMES <- toupper(added)
[17:28:19.826]                 for (kk in seq_along(NAMES)) {
[17:28:19.826]                   name <- added[[kk]]
[17:28:19.826]                   NAME <- NAMES[[kk]]
[17:28:19.826]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.826]                     next
[17:28:19.826]                   args[[name]] <- ""
[17:28:19.826]                 }
[17:28:19.826]                 NAMES <- toupper(removed)
[17:28:19.826]                 for (kk in seq_along(NAMES)) {
[17:28:19.826]                   name <- removed[[kk]]
[17:28:19.826]                   NAME <- NAMES[[kk]]
[17:28:19.826]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.826]                     next
[17:28:19.826]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.826]                 }
[17:28:19.826]                 if (length(args) > 0) 
[17:28:19.826]                   base::do.call(base::Sys.setenv, args = args)
[17:28:19.826]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:19.826]             }
[17:28:19.826]             else {
[17:28:19.826]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:19.826]             }
[17:28:19.826]             {
[17:28:19.826]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:19.826]                   0L) {
[17:28:19.826]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:19.826]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:19.826]                   base::options(opts)
[17:28:19.826]                 }
[17:28:19.826]                 {
[17:28:19.826]                   {
[17:28:19.826]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:19.826]                     NULL
[17:28:19.826]                   }
[17:28:19.826]                   options(future.plan = NULL)
[17:28:19.826]                   if (is.na(NA_character_)) 
[17:28:19.826]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.826]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:19.826]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:19.826]                     .init = FALSE)
[17:28:19.826]                 }
[17:28:19.826]             }
[17:28:19.826]         }
[17:28:19.826]     })
[17:28:19.826]     if (TRUE) {
[17:28:19.826]         base::sink(type = "output", split = FALSE)
[17:28:19.826]         if (TRUE) {
[17:28:19.826]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:19.826]         }
[17:28:19.826]         else {
[17:28:19.826]             ...future.result["stdout"] <- base::list(NULL)
[17:28:19.826]         }
[17:28:19.826]         base::close(...future.stdout)
[17:28:19.826]         ...future.stdout <- NULL
[17:28:19.826]     }
[17:28:19.826]     ...future.result$conditions <- ...future.conditions
[17:28:19.826]     ...future.result$finished <- base::Sys.time()
[17:28:19.826]     ...future.result
[17:28:19.826] }
[17:28:19.831] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:19.843] receiveMessageFromWorker() for ClusterFuture ...
[17:28:19.843] - Validating connection of MultisessionFuture
[17:28:19.843] - received message: FutureResult
[17:28:19.844] - Received FutureResult
[17:28:19.844] - Erased future from FutureRegistry
[17:28:19.844] result() for ClusterFuture ...
[17:28:19.844] - result already collected: FutureResult
[17:28:19.844] result() for ClusterFuture ... done
[17:28:19.844] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:19.844] result() for ClusterFuture ...
[17:28:19.845] - result already collected: FutureResult
[17:28:19.845] result() for ClusterFuture ... done
[17:28:19.845] result() for ClusterFuture ...
[17:28:19.845] - result already collected: FutureResult
[17:28:19.845] result() for ClusterFuture ... done
[17:28:19.846] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:19.846] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:19.847] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:19.847] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:19.847] MultisessionFuture started
[17:28:19.848] - Launch lazy future ... done
[17:28:19.848] run() for 'MultisessionFuture' ... done
[17:28:19.848] resolve() on list ...
[17:28:19.848]  recursive: 0
[17:28:19.848]  length: 4
[17:28:19.848] 
[17:28:19.849] Future #1
[17:28:19.849] result() for ClusterFuture ...
[17:28:19.849] - result already collected: FutureResult
[17:28:19.849] result() for ClusterFuture ... done
[17:28:19.849] result() for ClusterFuture ...
[17:28:19.849] - result already collected: FutureResult
[17:28:19.850] result() for ClusterFuture ... done
[17:28:19.850] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:28:19.850] - nx: 4
[17:28:19.850] - relay: TRUE
[17:28:19.850] - stdout: TRUE
[17:28:19.850] - signal: TRUE
[17:28:19.851] - resignal: FALSE
[17:28:19.851] - force: TRUE
[17:28:19.851] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:19.851] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:19.851]  - until=1
[17:28:19.851]  - relaying element #1
[17:28:19.851] result() for ClusterFuture ...
[17:28:19.852] - result already collected: FutureResult
[17:28:19.852] result() for ClusterFuture ... done
[17:28:19.852] result() for ClusterFuture ...
[17:28:19.852] - result already collected: FutureResult
[17:28:19.852] result() for ClusterFuture ... done
[17:28:19.852] result() for ClusterFuture ...
[17:28:19.853] - result already collected: FutureResult
[17:28:19.853] result() for ClusterFuture ... done
[17:28:19.853] result() for ClusterFuture ...
[17:28:19.853] - result already collected: FutureResult
[17:28:19.853] result() for ClusterFuture ... done
[17:28:19.853] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:19.854] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:19.854] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[17:28:19.854]  length: 3 (resolved future 1)
[17:28:19.854] Future #2
[17:28:19.854] result() for ClusterFuture ...
[17:28:19.854] - result already collected: FutureResult
[17:28:19.855] result() for ClusterFuture ... done
[17:28:19.855] result() for ClusterFuture ...
[17:28:19.855] - result already collected: FutureResult
[17:28:19.855] result() for ClusterFuture ... done
[17:28:19.855] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:28:19.855] - nx: 4
[17:28:19.855] - relay: TRUE
[17:28:19.856] - stdout: TRUE
[17:28:19.856] - signal: TRUE
[17:28:19.856] - resignal: FALSE
[17:28:19.856] - force: TRUE
[17:28:19.856] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:19.856] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:19.857]  - until=2
[17:28:19.857]  - relaying element #2
[17:28:19.857] result() for ClusterFuture ...
[17:28:19.857] - result already collected: FutureResult
[17:28:19.857] result() for ClusterFuture ... done
[17:28:19.857] result() for ClusterFuture ...
[17:28:19.858] - result already collected: FutureResult
[17:28:19.858] result() for ClusterFuture ... done
[17:28:19.858] result() for ClusterFuture ...
[17:28:19.858] - result already collected: FutureResult
[17:28:19.858] result() for ClusterFuture ... done
[17:28:19.858] result() for ClusterFuture ...
[17:28:19.859] - result already collected: FutureResult
[17:28:19.859] result() for ClusterFuture ... done
[17:28:19.859] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:19.859] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:19.859] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:28:19.859]  length: 2 (resolved future 2)
[17:28:19.860] receiveMessageFromWorker() for ClusterFuture ...
[17:28:19.860] - Validating connection of MultisessionFuture
[17:28:19.860] - received message: FutureResult
[17:28:19.860] - Received FutureResult
[17:28:19.861] - Erased future from FutureRegistry
[17:28:19.861] result() for ClusterFuture ...
[17:28:19.861] - result already collected: FutureResult
[17:28:19.861] result() for ClusterFuture ... done
[17:28:19.861] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:19.861] Future #3
[17:28:19.862] result() for ClusterFuture ...
[17:28:19.862] - result already collected: FutureResult
[17:28:19.862] result() for ClusterFuture ... done
[17:28:19.862] result() for ClusterFuture ...
[17:28:19.862] - result already collected: FutureResult
[17:28:19.862] result() for ClusterFuture ... done
[17:28:19.862] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:28:19.863] - nx: 4
[17:28:19.863] - relay: TRUE
[17:28:19.863] - stdout: TRUE
[17:28:19.863] - signal: TRUE
[17:28:19.863] - resignal: FALSE
[17:28:19.863] - force: TRUE
[17:28:19.864] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:19.864] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:19.864]  - until=3
[17:28:19.864]  - relaying element #3
[17:28:19.864] result() for ClusterFuture ...
[17:28:19.864] - result already collected: FutureResult
[17:28:19.864] result() for ClusterFuture ... done
[17:28:19.865] result() for ClusterFuture ...
[17:28:19.865] - result already collected: FutureResult
[17:28:19.865] result() for ClusterFuture ... done
[17:28:19.865] result() for ClusterFuture ...
[17:28:19.865] - result already collected: FutureResult
[17:28:19.865] result() for ClusterFuture ... done
[17:28:19.866] result() for ClusterFuture ...
[17:28:19.866] - result already collected: FutureResult
[17:28:19.866] result() for ClusterFuture ... done
[17:28:19.866] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:19.866] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:19.866] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:28:19.867]  length: 1 (resolved future 3)
[17:28:19.867] receiveMessageFromWorker() for ClusterFuture ...
[17:28:19.867] - Validating connection of MultisessionFuture
[17:28:19.867] - received message: FutureResult
[17:28:19.868] - Received FutureResult
[17:28:19.868] - Erased future from FutureRegistry
[17:28:19.868] result() for ClusterFuture ...
[17:28:19.868] - result already collected: FutureResult
[17:28:19.868] result() for ClusterFuture ... done
[17:28:19.868] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:19.869] Future #4
[17:28:19.869] result() for ClusterFuture ...
[17:28:19.869] - result already collected: FutureResult
[17:28:19.869] result() for ClusterFuture ... done
[17:28:19.869] result() for ClusterFuture ...
[17:28:19.869] - result already collected: FutureResult
[17:28:19.870] result() for ClusterFuture ... done
[17:28:19.870] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:28:19.870] - nx: 4
[17:28:19.870] - relay: TRUE
[17:28:19.870] - stdout: TRUE
[17:28:19.870] - signal: TRUE
[17:28:19.870] - resignal: FALSE
[17:28:19.871] - force: TRUE
[17:28:19.871] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:19.871] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:19.871]  - until=4
[17:28:19.871]  - relaying element #4
[17:28:19.871] result() for ClusterFuture ...
[17:28:19.872] - result already collected: FutureResult
[17:28:19.872] result() for ClusterFuture ... done
[17:28:19.872] result() for ClusterFuture ...
[17:28:19.872] - result already collected: FutureResult
[17:28:19.872] result() for ClusterFuture ... done
[17:28:19.872] result() for ClusterFuture ...
[17:28:19.873] - result already collected: FutureResult
[17:28:19.873] result() for ClusterFuture ... done
[17:28:19.873] result() for ClusterFuture ...
[17:28:19.873] - result already collected: FutureResult
[17:28:19.873] result() for ClusterFuture ... done
[17:28:19.873] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:19.873] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:19.874] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:28:19.874]  length: 0 (resolved future 4)
[17:28:19.874] Relaying remaining futures
[17:28:19.874] signalConditionsASAP(NULL, pos=0) ...
[17:28:19.874] - nx: 4
[17:28:19.874] - relay: TRUE
[17:28:19.875] - stdout: TRUE
[17:28:19.875] - signal: TRUE
[17:28:19.875] - resignal: FALSE
[17:28:19.875] - force: TRUE
[17:28:19.875] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:19.875] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:28:19.876] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:19.876] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:19.876] signalConditionsASAP(NULL, pos=0) ... done
[17:28:19.876] resolve() on list ... DONE
[17:28:19.876] result() for ClusterFuture ...
[17:28:19.876] - result already collected: FutureResult
[17:28:19.876] result() for ClusterFuture ... done
[17:28:19.877] result() for ClusterFuture ...
[17:28:19.877] - result already collected: FutureResult
[17:28:19.877] result() for ClusterFuture ... done
[17:28:19.877] result() for ClusterFuture ...
[17:28:19.877] - result already collected: FutureResult
[17:28:19.877] result() for ClusterFuture ... done
[17:28:19.878] result() for ClusterFuture ...
[17:28:19.878] - result already collected: FutureResult
[17:28:19.878] result() for ClusterFuture ... done
[17:28:19.878] result() for ClusterFuture ...
[17:28:19.878] - result already collected: FutureResult
[17:28:19.878] result() for ClusterFuture ... done
[17:28:19.879] result() for ClusterFuture ...
[17:28:19.879] - result already collected: FutureResult
[17:28:19.879] result() for ClusterFuture ... done
[17:28:19.879] result() for ClusterFuture ...
[17:28:19.879] - result already collected: FutureResult
[17:28:19.879] result() for ClusterFuture ... done
[17:28:19.879] result() for ClusterFuture ...
[17:28:19.880] - result already collected: FutureResult
[17:28:19.880] result() for ClusterFuture ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[17:28:19.880] getGlobalsAndPackages() ...
[17:28:19.880] Searching for globals...
[17:28:19.882] - globals found: [3] '{', 'sample', 'x'
[17:28:19.882] Searching for globals ... DONE
[17:28:19.882] Resolving globals: FALSE
[17:28:19.882] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:19.883] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:19.883] - globals: [1] 'x'
[17:28:19.883] 
[17:28:19.883] getGlobalsAndPackages() ... DONE
[17:28:19.884] run() for 'Future' ...
[17:28:19.884] - state: 'created'
[17:28:19.884] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:19.897] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:19.898] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:19.898]   - Field: 'node'
[17:28:19.898]   - Field: 'label'
[17:28:19.898]   - Field: 'local'
[17:28:19.898]   - Field: 'owner'
[17:28:19.899]   - Field: 'envir'
[17:28:19.899]   - Field: 'workers'
[17:28:19.899]   - Field: 'packages'
[17:28:19.899]   - Field: 'gc'
[17:28:19.899]   - Field: 'conditions'
[17:28:19.899]   - Field: 'persistent'
[17:28:19.900]   - Field: 'expr'
[17:28:19.900]   - Field: 'uuid'
[17:28:19.900]   - Field: 'seed'
[17:28:19.900]   - Field: 'version'
[17:28:19.900]   - Field: 'result'
[17:28:19.901]   - Field: 'asynchronous'
[17:28:19.901]   - Field: 'calls'
[17:28:19.901]   - Field: 'globals'
[17:28:19.901]   - Field: 'stdout'
[17:28:19.901]   - Field: 'earlySignal'
[17:28:19.901]   - Field: 'lazy'
[17:28:19.902]   - Field: 'state'
[17:28:19.902] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:19.902] - Launch lazy future ...
[17:28:19.902] Packages needed by the future expression (n = 0): <none>
[17:28:19.902] Packages needed by future strategies (n = 0): <none>
[17:28:19.903] {
[17:28:19.903]     {
[17:28:19.903]         {
[17:28:19.903]             ...future.startTime <- base::Sys.time()
[17:28:19.903]             {
[17:28:19.903]                 {
[17:28:19.903]                   {
[17:28:19.903]                     {
[17:28:19.903]                       base::local({
[17:28:19.903]                         has_future <- base::requireNamespace("future", 
[17:28:19.903]                           quietly = TRUE)
[17:28:19.903]                         if (has_future) {
[17:28:19.903]                           ns <- base::getNamespace("future")
[17:28:19.903]                           version <- ns[[".package"]][["version"]]
[17:28:19.903]                           if (is.null(version)) 
[17:28:19.903]                             version <- utils::packageVersion("future")
[17:28:19.903]                         }
[17:28:19.903]                         else {
[17:28:19.903]                           version <- NULL
[17:28:19.903]                         }
[17:28:19.903]                         if (!has_future || version < "1.8.0") {
[17:28:19.903]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:19.903]                             "", base::R.version$version.string), 
[17:28:19.903]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:19.903]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:19.903]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:19.903]                               "release", "version")], collapse = " "), 
[17:28:19.903]                             hostname = base::Sys.info()[["nodename"]])
[17:28:19.903]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:19.903]                             info)
[17:28:19.903]                           info <- base::paste(info, collapse = "; ")
[17:28:19.903]                           if (!has_future) {
[17:28:19.903]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:19.903]                               info)
[17:28:19.903]                           }
[17:28:19.903]                           else {
[17:28:19.903]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:19.903]                               info, version)
[17:28:19.903]                           }
[17:28:19.903]                           base::stop(msg)
[17:28:19.903]                         }
[17:28:19.903]                       })
[17:28:19.903]                     }
[17:28:19.903]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:19.903]                     base::options(mc.cores = 1L)
[17:28:19.903]                   }
[17:28:19.903]                   ...future.strategy.old <- future::plan("list")
[17:28:19.903]                   options(future.plan = NULL)
[17:28:19.903]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.903]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:19.903]                 }
[17:28:19.903]                 ...future.workdir <- getwd()
[17:28:19.903]             }
[17:28:19.903]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:19.903]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:19.903]         }
[17:28:19.903]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:19.903]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:19.903]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:19.903]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:19.903]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:19.903]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:19.903]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:19.903]             base::names(...future.oldOptions))
[17:28:19.903]     }
[17:28:19.903]     if (FALSE) {
[17:28:19.903]     }
[17:28:19.903]     else {
[17:28:19.903]         if (TRUE) {
[17:28:19.903]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:19.903]                 open = "w")
[17:28:19.903]         }
[17:28:19.903]         else {
[17:28:19.903]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:19.903]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:19.903]         }
[17:28:19.903]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:19.903]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:19.903]             base::sink(type = "output", split = FALSE)
[17:28:19.903]             base::close(...future.stdout)
[17:28:19.903]         }, add = TRUE)
[17:28:19.903]     }
[17:28:19.903]     ...future.frame <- base::sys.nframe()
[17:28:19.903]     ...future.conditions <- base::list()
[17:28:19.903]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:19.903]     if (FALSE) {
[17:28:19.903]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:19.903]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:19.903]     }
[17:28:19.903]     ...future.result <- base::tryCatch({
[17:28:19.903]         base::withCallingHandlers({
[17:28:19.903]             ...future.value <- base::withVisible(base::local({
[17:28:19.903]                 ...future.makeSendCondition <- base::local({
[17:28:19.903]                   sendCondition <- NULL
[17:28:19.903]                   function(frame = 1L) {
[17:28:19.903]                     if (is.function(sendCondition)) 
[17:28:19.903]                       return(sendCondition)
[17:28:19.903]                     ns <- getNamespace("parallel")
[17:28:19.903]                     if (exists("sendData", mode = "function", 
[17:28:19.903]                       envir = ns)) {
[17:28:19.903]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:19.903]                         envir = ns)
[17:28:19.903]                       envir <- sys.frame(frame)
[17:28:19.903]                       master <- NULL
[17:28:19.903]                       while (!identical(envir, .GlobalEnv) && 
[17:28:19.903]                         !identical(envir, emptyenv())) {
[17:28:19.903]                         if (exists("master", mode = "list", envir = envir, 
[17:28:19.903]                           inherits = FALSE)) {
[17:28:19.903]                           master <- get("master", mode = "list", 
[17:28:19.903]                             envir = envir, inherits = FALSE)
[17:28:19.903]                           if (inherits(master, c("SOCKnode", 
[17:28:19.903]                             "SOCK0node"))) {
[17:28:19.903]                             sendCondition <<- function(cond) {
[17:28:19.903]                               data <- list(type = "VALUE", value = cond, 
[17:28:19.903]                                 success = TRUE)
[17:28:19.903]                               parallel_sendData(master, data)
[17:28:19.903]                             }
[17:28:19.903]                             return(sendCondition)
[17:28:19.903]                           }
[17:28:19.903]                         }
[17:28:19.903]                         frame <- frame + 1L
[17:28:19.903]                         envir <- sys.frame(frame)
[17:28:19.903]                       }
[17:28:19.903]                     }
[17:28:19.903]                     sendCondition <<- function(cond) NULL
[17:28:19.903]                   }
[17:28:19.903]                 })
[17:28:19.903]                 withCallingHandlers({
[17:28:19.903]                   {
[17:28:19.903]                     sample(x, size = 1L)
[17:28:19.903]                   }
[17:28:19.903]                 }, immediateCondition = function(cond) {
[17:28:19.903]                   sendCondition <- ...future.makeSendCondition()
[17:28:19.903]                   sendCondition(cond)
[17:28:19.903]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.903]                   {
[17:28:19.903]                     inherits <- base::inherits
[17:28:19.903]                     invokeRestart <- base::invokeRestart
[17:28:19.903]                     is.null <- base::is.null
[17:28:19.903]                     muffled <- FALSE
[17:28:19.903]                     if (inherits(cond, "message")) {
[17:28:19.903]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:19.903]                       if (muffled) 
[17:28:19.903]                         invokeRestart("muffleMessage")
[17:28:19.903]                     }
[17:28:19.903]                     else if (inherits(cond, "warning")) {
[17:28:19.903]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:19.903]                       if (muffled) 
[17:28:19.903]                         invokeRestart("muffleWarning")
[17:28:19.903]                     }
[17:28:19.903]                     else if (inherits(cond, "condition")) {
[17:28:19.903]                       if (!is.null(pattern)) {
[17:28:19.903]                         computeRestarts <- base::computeRestarts
[17:28:19.903]                         grepl <- base::grepl
[17:28:19.903]                         restarts <- computeRestarts(cond)
[17:28:19.903]                         for (restart in restarts) {
[17:28:19.903]                           name <- restart$name
[17:28:19.903]                           if (is.null(name)) 
[17:28:19.903]                             next
[17:28:19.903]                           if (!grepl(pattern, name)) 
[17:28:19.903]                             next
[17:28:19.903]                           invokeRestart(restart)
[17:28:19.903]                           muffled <- TRUE
[17:28:19.903]                           break
[17:28:19.903]                         }
[17:28:19.903]                       }
[17:28:19.903]                     }
[17:28:19.903]                     invisible(muffled)
[17:28:19.903]                   }
[17:28:19.903]                   muffleCondition(cond)
[17:28:19.903]                 })
[17:28:19.903]             }))
[17:28:19.903]             future::FutureResult(value = ...future.value$value, 
[17:28:19.903]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.903]                   ...future.rng), globalenv = if (FALSE) 
[17:28:19.903]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:19.903]                     ...future.globalenv.names))
[17:28:19.903]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:19.903]         }, condition = base::local({
[17:28:19.903]             c <- base::c
[17:28:19.903]             inherits <- base::inherits
[17:28:19.903]             invokeRestart <- base::invokeRestart
[17:28:19.903]             length <- base::length
[17:28:19.903]             list <- base::list
[17:28:19.903]             seq.int <- base::seq.int
[17:28:19.903]             signalCondition <- base::signalCondition
[17:28:19.903]             sys.calls <- base::sys.calls
[17:28:19.903]             `[[` <- base::`[[`
[17:28:19.903]             `+` <- base::`+`
[17:28:19.903]             `<<-` <- base::`<<-`
[17:28:19.903]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:19.903]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:19.903]                   3L)]
[17:28:19.903]             }
[17:28:19.903]             function(cond) {
[17:28:19.903]                 is_error <- inherits(cond, "error")
[17:28:19.903]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:19.903]                   NULL)
[17:28:19.903]                 if (is_error) {
[17:28:19.903]                   sessionInformation <- function() {
[17:28:19.903]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:19.903]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:19.903]                       search = base::search(), system = base::Sys.info())
[17:28:19.903]                   }
[17:28:19.903]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.903]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:19.903]                     cond$call), session = sessionInformation(), 
[17:28:19.903]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:19.903]                   signalCondition(cond)
[17:28:19.903]                 }
[17:28:19.903]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:19.903]                 "immediateCondition"))) {
[17:28:19.903]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:19.903]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.903]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:19.903]                   if (TRUE && !signal) {
[17:28:19.903]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.903]                     {
[17:28:19.903]                       inherits <- base::inherits
[17:28:19.903]                       invokeRestart <- base::invokeRestart
[17:28:19.903]                       is.null <- base::is.null
[17:28:19.903]                       muffled <- FALSE
[17:28:19.903]                       if (inherits(cond, "message")) {
[17:28:19.903]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.903]                         if (muffled) 
[17:28:19.903]                           invokeRestart("muffleMessage")
[17:28:19.903]                       }
[17:28:19.903]                       else if (inherits(cond, "warning")) {
[17:28:19.903]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.903]                         if (muffled) 
[17:28:19.903]                           invokeRestart("muffleWarning")
[17:28:19.903]                       }
[17:28:19.903]                       else if (inherits(cond, "condition")) {
[17:28:19.903]                         if (!is.null(pattern)) {
[17:28:19.903]                           computeRestarts <- base::computeRestarts
[17:28:19.903]                           grepl <- base::grepl
[17:28:19.903]                           restarts <- computeRestarts(cond)
[17:28:19.903]                           for (restart in restarts) {
[17:28:19.903]                             name <- restart$name
[17:28:19.903]                             if (is.null(name)) 
[17:28:19.903]                               next
[17:28:19.903]                             if (!grepl(pattern, name)) 
[17:28:19.903]                               next
[17:28:19.903]                             invokeRestart(restart)
[17:28:19.903]                             muffled <- TRUE
[17:28:19.903]                             break
[17:28:19.903]                           }
[17:28:19.903]                         }
[17:28:19.903]                       }
[17:28:19.903]                       invisible(muffled)
[17:28:19.903]                     }
[17:28:19.903]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.903]                   }
[17:28:19.903]                 }
[17:28:19.903]                 else {
[17:28:19.903]                   if (TRUE) {
[17:28:19.903]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.903]                     {
[17:28:19.903]                       inherits <- base::inherits
[17:28:19.903]                       invokeRestart <- base::invokeRestart
[17:28:19.903]                       is.null <- base::is.null
[17:28:19.903]                       muffled <- FALSE
[17:28:19.903]                       if (inherits(cond, "message")) {
[17:28:19.903]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.903]                         if (muffled) 
[17:28:19.903]                           invokeRestart("muffleMessage")
[17:28:19.903]                       }
[17:28:19.903]                       else if (inherits(cond, "warning")) {
[17:28:19.903]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.903]                         if (muffled) 
[17:28:19.903]                           invokeRestart("muffleWarning")
[17:28:19.903]                       }
[17:28:19.903]                       else if (inherits(cond, "condition")) {
[17:28:19.903]                         if (!is.null(pattern)) {
[17:28:19.903]                           computeRestarts <- base::computeRestarts
[17:28:19.903]                           grepl <- base::grepl
[17:28:19.903]                           restarts <- computeRestarts(cond)
[17:28:19.903]                           for (restart in restarts) {
[17:28:19.903]                             name <- restart$name
[17:28:19.903]                             if (is.null(name)) 
[17:28:19.903]                               next
[17:28:19.903]                             if (!grepl(pattern, name)) 
[17:28:19.903]                               next
[17:28:19.903]                             invokeRestart(restart)
[17:28:19.903]                             muffled <- TRUE
[17:28:19.903]                             break
[17:28:19.903]                           }
[17:28:19.903]                         }
[17:28:19.903]                       }
[17:28:19.903]                       invisible(muffled)
[17:28:19.903]                     }
[17:28:19.903]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.903]                   }
[17:28:19.903]                 }
[17:28:19.903]             }
[17:28:19.903]         }))
[17:28:19.903]     }, error = function(ex) {
[17:28:19.903]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:19.903]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.903]                 ...future.rng), started = ...future.startTime, 
[17:28:19.903]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:19.903]             version = "1.8"), class = "FutureResult")
[17:28:19.903]     }, finally = {
[17:28:19.903]         if (!identical(...future.workdir, getwd())) 
[17:28:19.903]             setwd(...future.workdir)
[17:28:19.903]         {
[17:28:19.903]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:19.903]                 ...future.oldOptions$nwarnings <- NULL
[17:28:19.903]             }
[17:28:19.903]             base::options(...future.oldOptions)
[17:28:19.903]             if (.Platform$OS.type == "windows") {
[17:28:19.903]                 old_names <- names(...future.oldEnvVars)
[17:28:19.903]                 envs <- base::Sys.getenv()
[17:28:19.903]                 names <- names(envs)
[17:28:19.903]                 common <- intersect(names, old_names)
[17:28:19.903]                 added <- setdiff(names, old_names)
[17:28:19.903]                 removed <- setdiff(old_names, names)
[17:28:19.903]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:19.903]                   envs[common]]
[17:28:19.903]                 NAMES <- toupper(changed)
[17:28:19.903]                 args <- list()
[17:28:19.903]                 for (kk in seq_along(NAMES)) {
[17:28:19.903]                   name <- changed[[kk]]
[17:28:19.903]                   NAME <- NAMES[[kk]]
[17:28:19.903]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.903]                     next
[17:28:19.903]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.903]                 }
[17:28:19.903]                 NAMES <- toupper(added)
[17:28:19.903]                 for (kk in seq_along(NAMES)) {
[17:28:19.903]                   name <- added[[kk]]
[17:28:19.903]                   NAME <- NAMES[[kk]]
[17:28:19.903]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.903]                     next
[17:28:19.903]                   args[[name]] <- ""
[17:28:19.903]                 }
[17:28:19.903]                 NAMES <- toupper(removed)
[17:28:19.903]                 for (kk in seq_along(NAMES)) {
[17:28:19.903]                   name <- removed[[kk]]
[17:28:19.903]                   NAME <- NAMES[[kk]]
[17:28:19.903]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.903]                     next
[17:28:19.903]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.903]                 }
[17:28:19.903]                 if (length(args) > 0) 
[17:28:19.903]                   base::do.call(base::Sys.setenv, args = args)
[17:28:19.903]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:19.903]             }
[17:28:19.903]             else {
[17:28:19.903]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:19.903]             }
[17:28:19.903]             {
[17:28:19.903]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:19.903]                   0L) {
[17:28:19.903]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:19.903]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:19.903]                   base::options(opts)
[17:28:19.903]                 }
[17:28:19.903]                 {
[17:28:19.903]                   {
[17:28:19.903]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:19.903]                     NULL
[17:28:19.903]                   }
[17:28:19.903]                   options(future.plan = NULL)
[17:28:19.903]                   if (is.na(NA_character_)) 
[17:28:19.903]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.903]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:19.903]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:19.903]                     .init = FALSE)
[17:28:19.903]                 }
[17:28:19.903]             }
[17:28:19.903]         }
[17:28:19.903]     })
[17:28:19.903]     if (TRUE) {
[17:28:19.903]         base::sink(type = "output", split = FALSE)
[17:28:19.903]         if (TRUE) {
[17:28:19.903]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:19.903]         }
[17:28:19.903]         else {
[17:28:19.903]             ...future.result["stdout"] <- base::list(NULL)
[17:28:19.903]         }
[17:28:19.903]         base::close(...future.stdout)
[17:28:19.903]         ...future.stdout <- NULL
[17:28:19.903]     }
[17:28:19.903]     ...future.result$conditions <- ...future.conditions
[17:28:19.903]     ...future.result$finished <- base::Sys.time()
[17:28:19.903]     ...future.result
[17:28:19.903] }
[17:28:19.908] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:19.908] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:19.909] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:19.909] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:19.909] MultisessionFuture started
[17:28:19.910] - Launch lazy future ... done
[17:28:19.910] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-412784'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x0000026674f50ed0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:28:19.923] receiveMessageFromWorker() for ClusterFuture ...
[17:28:19.924] - Validating connection of MultisessionFuture
[17:28:19.924] - received message: FutureResult
[17:28:19.924] - Received FutureResult
[17:28:19.924] - Erased future from FutureRegistry
[17:28:19.924] result() for ClusterFuture ...
[17:28:19.925] - result already collected: FutureResult
[17:28:19.925] result() for ClusterFuture ... done
[17:28:19.925] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:19.925] getGlobalsAndPackages() ...
[17:28:19.925] Searching for globals...
[17:28:19.926] - globals found: [3] '{', 'sample', 'x'
[17:28:19.927] Searching for globals ... DONE
[17:28:19.927] Resolving globals: FALSE
[17:28:19.927] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:19.928] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:19.928] - globals: [1] 'x'
[17:28:19.928] 
[17:28:19.928] getGlobalsAndPackages() ... DONE
[17:28:19.929] run() for 'Future' ...
[17:28:19.929] - state: 'created'
[17:28:19.929] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:19.942] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:19.942] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:19.943]   - Field: 'node'
[17:28:19.943]   - Field: 'label'
[17:28:19.943]   - Field: 'local'
[17:28:19.943]   - Field: 'owner'
[17:28:19.943]   - Field: 'envir'
[17:28:19.943]   - Field: 'workers'
[17:28:19.944]   - Field: 'packages'
[17:28:19.944]   - Field: 'gc'
[17:28:19.944]   - Field: 'conditions'
[17:28:19.944]   - Field: 'persistent'
[17:28:19.944]   - Field: 'expr'
[17:28:19.945]   - Field: 'uuid'
[17:28:19.945]   - Field: 'seed'
[17:28:19.945]   - Field: 'version'
[17:28:19.945]   - Field: 'result'
[17:28:19.945]   - Field: 'asynchronous'
[17:28:19.945]   - Field: 'calls'
[17:28:19.946]   - Field: 'globals'
[17:28:19.946]   - Field: 'stdout'
[17:28:19.946]   - Field: 'earlySignal'
[17:28:19.946]   - Field: 'lazy'
[17:28:19.946]   - Field: 'state'
[17:28:19.946] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:19.947] - Launch lazy future ...
[17:28:19.947] Packages needed by the future expression (n = 0): <none>
[17:28:19.947] Packages needed by future strategies (n = 0): <none>
[17:28:19.948] {
[17:28:19.948]     {
[17:28:19.948]         {
[17:28:19.948]             ...future.startTime <- base::Sys.time()
[17:28:19.948]             {
[17:28:19.948]                 {
[17:28:19.948]                   {
[17:28:19.948]                     {
[17:28:19.948]                       base::local({
[17:28:19.948]                         has_future <- base::requireNamespace("future", 
[17:28:19.948]                           quietly = TRUE)
[17:28:19.948]                         if (has_future) {
[17:28:19.948]                           ns <- base::getNamespace("future")
[17:28:19.948]                           version <- ns[[".package"]][["version"]]
[17:28:19.948]                           if (is.null(version)) 
[17:28:19.948]                             version <- utils::packageVersion("future")
[17:28:19.948]                         }
[17:28:19.948]                         else {
[17:28:19.948]                           version <- NULL
[17:28:19.948]                         }
[17:28:19.948]                         if (!has_future || version < "1.8.0") {
[17:28:19.948]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:19.948]                             "", base::R.version$version.string), 
[17:28:19.948]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:19.948]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:19.948]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:19.948]                               "release", "version")], collapse = " "), 
[17:28:19.948]                             hostname = base::Sys.info()[["nodename"]])
[17:28:19.948]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:19.948]                             info)
[17:28:19.948]                           info <- base::paste(info, collapse = "; ")
[17:28:19.948]                           if (!has_future) {
[17:28:19.948]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:19.948]                               info)
[17:28:19.948]                           }
[17:28:19.948]                           else {
[17:28:19.948]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:19.948]                               info, version)
[17:28:19.948]                           }
[17:28:19.948]                           base::stop(msg)
[17:28:19.948]                         }
[17:28:19.948]                       })
[17:28:19.948]                     }
[17:28:19.948]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:19.948]                     base::options(mc.cores = 1L)
[17:28:19.948]                   }
[17:28:19.948]                   ...future.strategy.old <- future::plan("list")
[17:28:19.948]                   options(future.plan = NULL)
[17:28:19.948]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.948]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:19.948]                 }
[17:28:19.948]                 ...future.workdir <- getwd()
[17:28:19.948]             }
[17:28:19.948]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:19.948]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:19.948]         }
[17:28:19.948]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:19.948]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:19.948]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:19.948]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:19.948]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:19.948]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:19.948]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:19.948]             base::names(...future.oldOptions))
[17:28:19.948]     }
[17:28:19.948]     if (FALSE) {
[17:28:19.948]     }
[17:28:19.948]     else {
[17:28:19.948]         if (TRUE) {
[17:28:19.948]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:19.948]                 open = "w")
[17:28:19.948]         }
[17:28:19.948]         else {
[17:28:19.948]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:19.948]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:19.948]         }
[17:28:19.948]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:19.948]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:19.948]             base::sink(type = "output", split = FALSE)
[17:28:19.948]             base::close(...future.stdout)
[17:28:19.948]         }, add = TRUE)
[17:28:19.948]     }
[17:28:19.948]     ...future.frame <- base::sys.nframe()
[17:28:19.948]     ...future.conditions <- base::list()
[17:28:19.948]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:19.948]     if (FALSE) {
[17:28:19.948]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:19.948]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:19.948]     }
[17:28:19.948]     ...future.result <- base::tryCatch({
[17:28:19.948]         base::withCallingHandlers({
[17:28:19.948]             ...future.value <- base::withVisible(base::local({
[17:28:19.948]                 ...future.makeSendCondition <- base::local({
[17:28:19.948]                   sendCondition <- NULL
[17:28:19.948]                   function(frame = 1L) {
[17:28:19.948]                     if (is.function(sendCondition)) 
[17:28:19.948]                       return(sendCondition)
[17:28:19.948]                     ns <- getNamespace("parallel")
[17:28:19.948]                     if (exists("sendData", mode = "function", 
[17:28:19.948]                       envir = ns)) {
[17:28:19.948]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:19.948]                         envir = ns)
[17:28:19.948]                       envir <- sys.frame(frame)
[17:28:19.948]                       master <- NULL
[17:28:19.948]                       while (!identical(envir, .GlobalEnv) && 
[17:28:19.948]                         !identical(envir, emptyenv())) {
[17:28:19.948]                         if (exists("master", mode = "list", envir = envir, 
[17:28:19.948]                           inherits = FALSE)) {
[17:28:19.948]                           master <- get("master", mode = "list", 
[17:28:19.948]                             envir = envir, inherits = FALSE)
[17:28:19.948]                           if (inherits(master, c("SOCKnode", 
[17:28:19.948]                             "SOCK0node"))) {
[17:28:19.948]                             sendCondition <<- function(cond) {
[17:28:19.948]                               data <- list(type = "VALUE", value = cond, 
[17:28:19.948]                                 success = TRUE)
[17:28:19.948]                               parallel_sendData(master, data)
[17:28:19.948]                             }
[17:28:19.948]                             return(sendCondition)
[17:28:19.948]                           }
[17:28:19.948]                         }
[17:28:19.948]                         frame <- frame + 1L
[17:28:19.948]                         envir <- sys.frame(frame)
[17:28:19.948]                       }
[17:28:19.948]                     }
[17:28:19.948]                     sendCondition <<- function(cond) NULL
[17:28:19.948]                   }
[17:28:19.948]                 })
[17:28:19.948]                 withCallingHandlers({
[17:28:19.948]                   {
[17:28:19.948]                     sample(x, size = 1L)
[17:28:19.948]                   }
[17:28:19.948]                 }, immediateCondition = function(cond) {
[17:28:19.948]                   sendCondition <- ...future.makeSendCondition()
[17:28:19.948]                   sendCondition(cond)
[17:28:19.948]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.948]                   {
[17:28:19.948]                     inherits <- base::inherits
[17:28:19.948]                     invokeRestart <- base::invokeRestart
[17:28:19.948]                     is.null <- base::is.null
[17:28:19.948]                     muffled <- FALSE
[17:28:19.948]                     if (inherits(cond, "message")) {
[17:28:19.948]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:19.948]                       if (muffled) 
[17:28:19.948]                         invokeRestart("muffleMessage")
[17:28:19.948]                     }
[17:28:19.948]                     else if (inherits(cond, "warning")) {
[17:28:19.948]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:19.948]                       if (muffled) 
[17:28:19.948]                         invokeRestart("muffleWarning")
[17:28:19.948]                     }
[17:28:19.948]                     else if (inherits(cond, "condition")) {
[17:28:19.948]                       if (!is.null(pattern)) {
[17:28:19.948]                         computeRestarts <- base::computeRestarts
[17:28:19.948]                         grepl <- base::grepl
[17:28:19.948]                         restarts <- computeRestarts(cond)
[17:28:19.948]                         for (restart in restarts) {
[17:28:19.948]                           name <- restart$name
[17:28:19.948]                           if (is.null(name)) 
[17:28:19.948]                             next
[17:28:19.948]                           if (!grepl(pattern, name)) 
[17:28:19.948]                             next
[17:28:19.948]                           invokeRestart(restart)
[17:28:19.948]                           muffled <- TRUE
[17:28:19.948]                           break
[17:28:19.948]                         }
[17:28:19.948]                       }
[17:28:19.948]                     }
[17:28:19.948]                     invisible(muffled)
[17:28:19.948]                   }
[17:28:19.948]                   muffleCondition(cond)
[17:28:19.948]                 })
[17:28:19.948]             }))
[17:28:19.948]             future::FutureResult(value = ...future.value$value, 
[17:28:19.948]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.948]                   ...future.rng), globalenv = if (FALSE) 
[17:28:19.948]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:19.948]                     ...future.globalenv.names))
[17:28:19.948]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:19.948]         }, condition = base::local({
[17:28:19.948]             c <- base::c
[17:28:19.948]             inherits <- base::inherits
[17:28:19.948]             invokeRestart <- base::invokeRestart
[17:28:19.948]             length <- base::length
[17:28:19.948]             list <- base::list
[17:28:19.948]             seq.int <- base::seq.int
[17:28:19.948]             signalCondition <- base::signalCondition
[17:28:19.948]             sys.calls <- base::sys.calls
[17:28:19.948]             `[[` <- base::`[[`
[17:28:19.948]             `+` <- base::`+`
[17:28:19.948]             `<<-` <- base::`<<-`
[17:28:19.948]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:19.948]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:19.948]                   3L)]
[17:28:19.948]             }
[17:28:19.948]             function(cond) {
[17:28:19.948]                 is_error <- inherits(cond, "error")
[17:28:19.948]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:19.948]                   NULL)
[17:28:19.948]                 if (is_error) {
[17:28:19.948]                   sessionInformation <- function() {
[17:28:19.948]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:19.948]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:19.948]                       search = base::search(), system = base::Sys.info())
[17:28:19.948]                   }
[17:28:19.948]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.948]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:19.948]                     cond$call), session = sessionInformation(), 
[17:28:19.948]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:19.948]                   signalCondition(cond)
[17:28:19.948]                 }
[17:28:19.948]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:19.948]                 "immediateCondition"))) {
[17:28:19.948]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:19.948]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.948]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:19.948]                   if (TRUE && !signal) {
[17:28:19.948]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.948]                     {
[17:28:19.948]                       inherits <- base::inherits
[17:28:19.948]                       invokeRestart <- base::invokeRestart
[17:28:19.948]                       is.null <- base::is.null
[17:28:19.948]                       muffled <- FALSE
[17:28:19.948]                       if (inherits(cond, "message")) {
[17:28:19.948]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.948]                         if (muffled) 
[17:28:19.948]                           invokeRestart("muffleMessage")
[17:28:19.948]                       }
[17:28:19.948]                       else if (inherits(cond, "warning")) {
[17:28:19.948]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.948]                         if (muffled) 
[17:28:19.948]                           invokeRestart("muffleWarning")
[17:28:19.948]                       }
[17:28:19.948]                       else if (inherits(cond, "condition")) {
[17:28:19.948]                         if (!is.null(pattern)) {
[17:28:19.948]                           computeRestarts <- base::computeRestarts
[17:28:19.948]                           grepl <- base::grepl
[17:28:19.948]                           restarts <- computeRestarts(cond)
[17:28:19.948]                           for (restart in restarts) {
[17:28:19.948]                             name <- restart$name
[17:28:19.948]                             if (is.null(name)) 
[17:28:19.948]                               next
[17:28:19.948]                             if (!grepl(pattern, name)) 
[17:28:19.948]                               next
[17:28:19.948]                             invokeRestart(restart)
[17:28:19.948]                             muffled <- TRUE
[17:28:19.948]                             break
[17:28:19.948]                           }
[17:28:19.948]                         }
[17:28:19.948]                       }
[17:28:19.948]                       invisible(muffled)
[17:28:19.948]                     }
[17:28:19.948]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.948]                   }
[17:28:19.948]                 }
[17:28:19.948]                 else {
[17:28:19.948]                   if (TRUE) {
[17:28:19.948]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.948]                     {
[17:28:19.948]                       inherits <- base::inherits
[17:28:19.948]                       invokeRestart <- base::invokeRestart
[17:28:19.948]                       is.null <- base::is.null
[17:28:19.948]                       muffled <- FALSE
[17:28:19.948]                       if (inherits(cond, "message")) {
[17:28:19.948]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.948]                         if (muffled) 
[17:28:19.948]                           invokeRestart("muffleMessage")
[17:28:19.948]                       }
[17:28:19.948]                       else if (inherits(cond, "warning")) {
[17:28:19.948]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.948]                         if (muffled) 
[17:28:19.948]                           invokeRestart("muffleWarning")
[17:28:19.948]                       }
[17:28:19.948]                       else if (inherits(cond, "condition")) {
[17:28:19.948]                         if (!is.null(pattern)) {
[17:28:19.948]                           computeRestarts <- base::computeRestarts
[17:28:19.948]                           grepl <- base::grepl
[17:28:19.948]                           restarts <- computeRestarts(cond)
[17:28:19.948]                           for (restart in restarts) {
[17:28:19.948]                             name <- restart$name
[17:28:19.948]                             if (is.null(name)) 
[17:28:19.948]                               next
[17:28:19.948]                             if (!grepl(pattern, name)) 
[17:28:19.948]                               next
[17:28:19.948]                             invokeRestart(restart)
[17:28:19.948]                             muffled <- TRUE
[17:28:19.948]                             break
[17:28:19.948]                           }
[17:28:19.948]                         }
[17:28:19.948]                       }
[17:28:19.948]                       invisible(muffled)
[17:28:19.948]                     }
[17:28:19.948]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.948]                   }
[17:28:19.948]                 }
[17:28:19.948]             }
[17:28:19.948]         }))
[17:28:19.948]     }, error = function(ex) {
[17:28:19.948]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:19.948]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.948]                 ...future.rng), started = ...future.startTime, 
[17:28:19.948]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:19.948]             version = "1.8"), class = "FutureResult")
[17:28:19.948]     }, finally = {
[17:28:19.948]         if (!identical(...future.workdir, getwd())) 
[17:28:19.948]             setwd(...future.workdir)
[17:28:19.948]         {
[17:28:19.948]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:19.948]                 ...future.oldOptions$nwarnings <- NULL
[17:28:19.948]             }
[17:28:19.948]             base::options(...future.oldOptions)
[17:28:19.948]             if (.Platform$OS.type == "windows") {
[17:28:19.948]                 old_names <- names(...future.oldEnvVars)
[17:28:19.948]                 envs <- base::Sys.getenv()
[17:28:19.948]                 names <- names(envs)
[17:28:19.948]                 common <- intersect(names, old_names)
[17:28:19.948]                 added <- setdiff(names, old_names)
[17:28:19.948]                 removed <- setdiff(old_names, names)
[17:28:19.948]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:19.948]                   envs[common]]
[17:28:19.948]                 NAMES <- toupper(changed)
[17:28:19.948]                 args <- list()
[17:28:19.948]                 for (kk in seq_along(NAMES)) {
[17:28:19.948]                   name <- changed[[kk]]
[17:28:19.948]                   NAME <- NAMES[[kk]]
[17:28:19.948]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.948]                     next
[17:28:19.948]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.948]                 }
[17:28:19.948]                 NAMES <- toupper(added)
[17:28:19.948]                 for (kk in seq_along(NAMES)) {
[17:28:19.948]                   name <- added[[kk]]
[17:28:19.948]                   NAME <- NAMES[[kk]]
[17:28:19.948]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.948]                     next
[17:28:19.948]                   args[[name]] <- ""
[17:28:19.948]                 }
[17:28:19.948]                 NAMES <- toupper(removed)
[17:28:19.948]                 for (kk in seq_along(NAMES)) {
[17:28:19.948]                   name <- removed[[kk]]
[17:28:19.948]                   NAME <- NAMES[[kk]]
[17:28:19.948]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.948]                     next
[17:28:19.948]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.948]                 }
[17:28:19.948]                 if (length(args) > 0) 
[17:28:19.948]                   base::do.call(base::Sys.setenv, args = args)
[17:28:19.948]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:19.948]             }
[17:28:19.948]             else {
[17:28:19.948]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:19.948]             }
[17:28:19.948]             {
[17:28:19.948]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:19.948]                   0L) {
[17:28:19.948]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:19.948]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:19.948]                   base::options(opts)
[17:28:19.948]                 }
[17:28:19.948]                 {
[17:28:19.948]                   {
[17:28:19.948]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:19.948]                     NULL
[17:28:19.948]                   }
[17:28:19.948]                   options(future.plan = NULL)
[17:28:19.948]                   if (is.na(NA_character_)) 
[17:28:19.948]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.948]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:19.948]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:19.948]                     .init = FALSE)
[17:28:19.948]                 }
[17:28:19.948]             }
[17:28:19.948]         }
[17:28:19.948]     })
[17:28:19.948]     if (TRUE) {
[17:28:19.948]         base::sink(type = "output", split = FALSE)
[17:28:19.948]         if (TRUE) {
[17:28:19.948]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:19.948]         }
[17:28:19.948]         else {
[17:28:19.948]             ...future.result["stdout"] <- base::list(NULL)
[17:28:19.948]         }
[17:28:19.948]         base::close(...future.stdout)
[17:28:19.948]         ...future.stdout <- NULL
[17:28:19.948]     }
[17:28:19.948]     ...future.result$conditions <- ...future.conditions
[17:28:19.948]     ...future.result$finished <- base::Sys.time()
[17:28:19.948]     ...future.result
[17:28:19.948] }
[17:28:19.953] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:19.953] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:19.953] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:19.953] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:19.954] MultisessionFuture started
[17:28:19.954] - Launch lazy future ... done
[17:28:19.954] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-544267'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x0000026674f50ed0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:28:19.970] receiveMessageFromWorker() for ClusterFuture ...
[17:28:19.970] - Validating connection of MultisessionFuture
[17:28:19.970] - received message: FutureResult
[17:28:19.970] - Received FutureResult
[17:28:19.970] - Erased future from FutureRegistry
[17:28:19.971] result() for ClusterFuture ...
[17:28:19.971] - result already collected: FutureResult
[17:28:19.971] result() for ClusterFuture ... done
[17:28:19.971] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:19.971] getGlobalsAndPackages() ...
[17:28:19.971] Searching for globals...
[17:28:19.973] - globals found: [3] '{', 'sample', 'x'
[17:28:19.973] Searching for globals ... DONE
[17:28:19.973] Resolving globals: FALSE
[17:28:19.973] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:19.974] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:19.974] - globals: [1] 'x'
[17:28:19.974] 
[17:28:19.974] getGlobalsAndPackages() ... DONE
[17:28:19.975] run() for 'Future' ...
[17:28:19.975] - state: 'created'
[17:28:19.975] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:19.988] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:19.989] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:19.989]   - Field: 'node'
[17:28:19.989]   - Field: 'label'
[17:28:19.989]   - Field: 'local'
[17:28:19.989]   - Field: 'owner'
[17:28:19.989]   - Field: 'envir'
[17:28:19.990]   - Field: 'workers'
[17:28:19.990]   - Field: 'packages'
[17:28:19.990]   - Field: 'gc'
[17:28:19.990]   - Field: 'conditions'
[17:28:19.990]   - Field: 'persistent'
[17:28:19.991]   - Field: 'expr'
[17:28:19.991]   - Field: 'uuid'
[17:28:19.991]   - Field: 'seed'
[17:28:19.991]   - Field: 'version'
[17:28:19.991]   - Field: 'result'
[17:28:19.991]   - Field: 'asynchronous'
[17:28:19.992]   - Field: 'calls'
[17:28:19.992]   - Field: 'globals'
[17:28:19.992]   - Field: 'stdout'
[17:28:19.992]   - Field: 'earlySignal'
[17:28:19.992]   - Field: 'lazy'
[17:28:19.992]   - Field: 'state'
[17:28:19.993] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:19.993] - Launch lazy future ...
[17:28:19.993] Packages needed by the future expression (n = 0): <none>
[17:28:19.993] Packages needed by future strategies (n = 0): <none>
[17:28:19.994] {
[17:28:19.994]     {
[17:28:19.994]         {
[17:28:19.994]             ...future.startTime <- base::Sys.time()
[17:28:19.994]             {
[17:28:19.994]                 {
[17:28:19.994]                   {
[17:28:19.994]                     {
[17:28:19.994]                       base::local({
[17:28:19.994]                         has_future <- base::requireNamespace("future", 
[17:28:19.994]                           quietly = TRUE)
[17:28:19.994]                         if (has_future) {
[17:28:19.994]                           ns <- base::getNamespace("future")
[17:28:19.994]                           version <- ns[[".package"]][["version"]]
[17:28:19.994]                           if (is.null(version)) 
[17:28:19.994]                             version <- utils::packageVersion("future")
[17:28:19.994]                         }
[17:28:19.994]                         else {
[17:28:19.994]                           version <- NULL
[17:28:19.994]                         }
[17:28:19.994]                         if (!has_future || version < "1.8.0") {
[17:28:19.994]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:19.994]                             "", base::R.version$version.string), 
[17:28:19.994]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:19.994]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:19.994]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:19.994]                               "release", "version")], collapse = " "), 
[17:28:19.994]                             hostname = base::Sys.info()[["nodename"]])
[17:28:19.994]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:19.994]                             info)
[17:28:19.994]                           info <- base::paste(info, collapse = "; ")
[17:28:19.994]                           if (!has_future) {
[17:28:19.994]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:19.994]                               info)
[17:28:19.994]                           }
[17:28:19.994]                           else {
[17:28:19.994]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:19.994]                               info, version)
[17:28:19.994]                           }
[17:28:19.994]                           base::stop(msg)
[17:28:19.994]                         }
[17:28:19.994]                       })
[17:28:19.994]                     }
[17:28:19.994]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:19.994]                     base::options(mc.cores = 1L)
[17:28:19.994]                   }
[17:28:19.994]                   ...future.strategy.old <- future::plan("list")
[17:28:19.994]                   options(future.plan = NULL)
[17:28:19.994]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.994]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:19.994]                 }
[17:28:19.994]                 ...future.workdir <- getwd()
[17:28:19.994]             }
[17:28:19.994]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:19.994]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:19.994]         }
[17:28:19.994]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:19.994]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:19.994]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:19.994]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:19.994]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:19.994]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:19.994]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:19.994]             base::names(...future.oldOptions))
[17:28:19.994]     }
[17:28:19.994]     if (FALSE) {
[17:28:19.994]     }
[17:28:19.994]     else {
[17:28:19.994]         if (TRUE) {
[17:28:19.994]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:19.994]                 open = "w")
[17:28:19.994]         }
[17:28:19.994]         else {
[17:28:19.994]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:19.994]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:19.994]         }
[17:28:19.994]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:19.994]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:19.994]             base::sink(type = "output", split = FALSE)
[17:28:19.994]             base::close(...future.stdout)
[17:28:19.994]         }, add = TRUE)
[17:28:19.994]     }
[17:28:19.994]     ...future.frame <- base::sys.nframe()
[17:28:19.994]     ...future.conditions <- base::list()
[17:28:19.994]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:19.994]     if (FALSE) {
[17:28:19.994]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:19.994]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:19.994]     }
[17:28:19.994]     ...future.result <- base::tryCatch({
[17:28:19.994]         base::withCallingHandlers({
[17:28:19.994]             ...future.value <- base::withVisible(base::local({
[17:28:19.994]                 ...future.makeSendCondition <- base::local({
[17:28:19.994]                   sendCondition <- NULL
[17:28:19.994]                   function(frame = 1L) {
[17:28:19.994]                     if (is.function(sendCondition)) 
[17:28:19.994]                       return(sendCondition)
[17:28:19.994]                     ns <- getNamespace("parallel")
[17:28:19.994]                     if (exists("sendData", mode = "function", 
[17:28:19.994]                       envir = ns)) {
[17:28:19.994]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:19.994]                         envir = ns)
[17:28:19.994]                       envir <- sys.frame(frame)
[17:28:19.994]                       master <- NULL
[17:28:19.994]                       while (!identical(envir, .GlobalEnv) && 
[17:28:19.994]                         !identical(envir, emptyenv())) {
[17:28:19.994]                         if (exists("master", mode = "list", envir = envir, 
[17:28:19.994]                           inherits = FALSE)) {
[17:28:19.994]                           master <- get("master", mode = "list", 
[17:28:19.994]                             envir = envir, inherits = FALSE)
[17:28:19.994]                           if (inherits(master, c("SOCKnode", 
[17:28:19.994]                             "SOCK0node"))) {
[17:28:19.994]                             sendCondition <<- function(cond) {
[17:28:19.994]                               data <- list(type = "VALUE", value = cond, 
[17:28:19.994]                                 success = TRUE)
[17:28:19.994]                               parallel_sendData(master, data)
[17:28:19.994]                             }
[17:28:19.994]                             return(sendCondition)
[17:28:19.994]                           }
[17:28:19.994]                         }
[17:28:19.994]                         frame <- frame + 1L
[17:28:19.994]                         envir <- sys.frame(frame)
[17:28:19.994]                       }
[17:28:19.994]                     }
[17:28:19.994]                     sendCondition <<- function(cond) NULL
[17:28:19.994]                   }
[17:28:19.994]                 })
[17:28:19.994]                 withCallingHandlers({
[17:28:19.994]                   {
[17:28:19.994]                     sample(x, size = 1L)
[17:28:19.994]                   }
[17:28:19.994]                 }, immediateCondition = function(cond) {
[17:28:19.994]                   sendCondition <- ...future.makeSendCondition()
[17:28:19.994]                   sendCondition(cond)
[17:28:19.994]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.994]                   {
[17:28:19.994]                     inherits <- base::inherits
[17:28:19.994]                     invokeRestart <- base::invokeRestart
[17:28:19.994]                     is.null <- base::is.null
[17:28:19.994]                     muffled <- FALSE
[17:28:19.994]                     if (inherits(cond, "message")) {
[17:28:19.994]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:19.994]                       if (muffled) 
[17:28:19.994]                         invokeRestart("muffleMessage")
[17:28:19.994]                     }
[17:28:19.994]                     else if (inherits(cond, "warning")) {
[17:28:19.994]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:19.994]                       if (muffled) 
[17:28:19.994]                         invokeRestart("muffleWarning")
[17:28:19.994]                     }
[17:28:19.994]                     else if (inherits(cond, "condition")) {
[17:28:19.994]                       if (!is.null(pattern)) {
[17:28:19.994]                         computeRestarts <- base::computeRestarts
[17:28:19.994]                         grepl <- base::grepl
[17:28:19.994]                         restarts <- computeRestarts(cond)
[17:28:19.994]                         for (restart in restarts) {
[17:28:19.994]                           name <- restart$name
[17:28:19.994]                           if (is.null(name)) 
[17:28:19.994]                             next
[17:28:19.994]                           if (!grepl(pattern, name)) 
[17:28:19.994]                             next
[17:28:19.994]                           invokeRestart(restart)
[17:28:19.994]                           muffled <- TRUE
[17:28:19.994]                           break
[17:28:19.994]                         }
[17:28:19.994]                       }
[17:28:19.994]                     }
[17:28:19.994]                     invisible(muffled)
[17:28:19.994]                   }
[17:28:19.994]                   muffleCondition(cond)
[17:28:19.994]                 })
[17:28:19.994]             }))
[17:28:19.994]             future::FutureResult(value = ...future.value$value, 
[17:28:19.994]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.994]                   ...future.rng), globalenv = if (FALSE) 
[17:28:19.994]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:19.994]                     ...future.globalenv.names))
[17:28:19.994]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:19.994]         }, condition = base::local({
[17:28:19.994]             c <- base::c
[17:28:19.994]             inherits <- base::inherits
[17:28:19.994]             invokeRestart <- base::invokeRestart
[17:28:19.994]             length <- base::length
[17:28:19.994]             list <- base::list
[17:28:19.994]             seq.int <- base::seq.int
[17:28:19.994]             signalCondition <- base::signalCondition
[17:28:19.994]             sys.calls <- base::sys.calls
[17:28:19.994]             `[[` <- base::`[[`
[17:28:19.994]             `+` <- base::`+`
[17:28:19.994]             `<<-` <- base::`<<-`
[17:28:19.994]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:19.994]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:19.994]                   3L)]
[17:28:19.994]             }
[17:28:19.994]             function(cond) {
[17:28:19.994]                 is_error <- inherits(cond, "error")
[17:28:19.994]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:19.994]                   NULL)
[17:28:19.994]                 if (is_error) {
[17:28:19.994]                   sessionInformation <- function() {
[17:28:19.994]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:19.994]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:19.994]                       search = base::search(), system = base::Sys.info())
[17:28:19.994]                   }
[17:28:19.994]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.994]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:19.994]                     cond$call), session = sessionInformation(), 
[17:28:19.994]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:19.994]                   signalCondition(cond)
[17:28:19.994]                 }
[17:28:19.994]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:19.994]                 "immediateCondition"))) {
[17:28:19.994]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:19.994]                   ...future.conditions[[length(...future.conditions) + 
[17:28:19.994]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:19.994]                   if (TRUE && !signal) {
[17:28:19.994]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.994]                     {
[17:28:19.994]                       inherits <- base::inherits
[17:28:19.994]                       invokeRestart <- base::invokeRestart
[17:28:19.994]                       is.null <- base::is.null
[17:28:19.994]                       muffled <- FALSE
[17:28:19.994]                       if (inherits(cond, "message")) {
[17:28:19.994]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.994]                         if (muffled) 
[17:28:19.994]                           invokeRestart("muffleMessage")
[17:28:19.994]                       }
[17:28:19.994]                       else if (inherits(cond, "warning")) {
[17:28:19.994]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.994]                         if (muffled) 
[17:28:19.994]                           invokeRestart("muffleWarning")
[17:28:19.994]                       }
[17:28:19.994]                       else if (inherits(cond, "condition")) {
[17:28:19.994]                         if (!is.null(pattern)) {
[17:28:19.994]                           computeRestarts <- base::computeRestarts
[17:28:19.994]                           grepl <- base::grepl
[17:28:19.994]                           restarts <- computeRestarts(cond)
[17:28:19.994]                           for (restart in restarts) {
[17:28:19.994]                             name <- restart$name
[17:28:19.994]                             if (is.null(name)) 
[17:28:19.994]                               next
[17:28:19.994]                             if (!grepl(pattern, name)) 
[17:28:19.994]                               next
[17:28:19.994]                             invokeRestart(restart)
[17:28:19.994]                             muffled <- TRUE
[17:28:19.994]                             break
[17:28:19.994]                           }
[17:28:19.994]                         }
[17:28:19.994]                       }
[17:28:19.994]                       invisible(muffled)
[17:28:19.994]                     }
[17:28:19.994]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.994]                   }
[17:28:19.994]                 }
[17:28:19.994]                 else {
[17:28:19.994]                   if (TRUE) {
[17:28:19.994]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:19.994]                     {
[17:28:19.994]                       inherits <- base::inherits
[17:28:19.994]                       invokeRestart <- base::invokeRestart
[17:28:19.994]                       is.null <- base::is.null
[17:28:19.994]                       muffled <- FALSE
[17:28:19.994]                       if (inherits(cond, "message")) {
[17:28:19.994]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:19.994]                         if (muffled) 
[17:28:19.994]                           invokeRestart("muffleMessage")
[17:28:19.994]                       }
[17:28:19.994]                       else if (inherits(cond, "warning")) {
[17:28:19.994]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:19.994]                         if (muffled) 
[17:28:19.994]                           invokeRestart("muffleWarning")
[17:28:19.994]                       }
[17:28:19.994]                       else if (inherits(cond, "condition")) {
[17:28:19.994]                         if (!is.null(pattern)) {
[17:28:19.994]                           computeRestarts <- base::computeRestarts
[17:28:19.994]                           grepl <- base::grepl
[17:28:19.994]                           restarts <- computeRestarts(cond)
[17:28:19.994]                           for (restart in restarts) {
[17:28:19.994]                             name <- restart$name
[17:28:19.994]                             if (is.null(name)) 
[17:28:19.994]                               next
[17:28:19.994]                             if (!grepl(pattern, name)) 
[17:28:19.994]                               next
[17:28:19.994]                             invokeRestart(restart)
[17:28:19.994]                             muffled <- TRUE
[17:28:19.994]                             break
[17:28:19.994]                           }
[17:28:19.994]                         }
[17:28:19.994]                       }
[17:28:19.994]                       invisible(muffled)
[17:28:19.994]                     }
[17:28:19.994]                     muffleCondition(cond, pattern = "^muffle")
[17:28:19.994]                   }
[17:28:19.994]                 }
[17:28:19.994]             }
[17:28:19.994]         }))
[17:28:19.994]     }, error = function(ex) {
[17:28:19.994]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:19.994]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:19.994]                 ...future.rng), started = ...future.startTime, 
[17:28:19.994]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:19.994]             version = "1.8"), class = "FutureResult")
[17:28:19.994]     }, finally = {
[17:28:19.994]         if (!identical(...future.workdir, getwd())) 
[17:28:19.994]             setwd(...future.workdir)
[17:28:19.994]         {
[17:28:19.994]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:19.994]                 ...future.oldOptions$nwarnings <- NULL
[17:28:19.994]             }
[17:28:19.994]             base::options(...future.oldOptions)
[17:28:19.994]             if (.Platform$OS.type == "windows") {
[17:28:19.994]                 old_names <- names(...future.oldEnvVars)
[17:28:19.994]                 envs <- base::Sys.getenv()
[17:28:19.994]                 names <- names(envs)
[17:28:19.994]                 common <- intersect(names, old_names)
[17:28:19.994]                 added <- setdiff(names, old_names)
[17:28:19.994]                 removed <- setdiff(old_names, names)
[17:28:19.994]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:19.994]                   envs[common]]
[17:28:19.994]                 NAMES <- toupper(changed)
[17:28:19.994]                 args <- list()
[17:28:19.994]                 for (kk in seq_along(NAMES)) {
[17:28:19.994]                   name <- changed[[kk]]
[17:28:19.994]                   NAME <- NAMES[[kk]]
[17:28:19.994]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.994]                     next
[17:28:19.994]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.994]                 }
[17:28:19.994]                 NAMES <- toupper(added)
[17:28:19.994]                 for (kk in seq_along(NAMES)) {
[17:28:19.994]                   name <- added[[kk]]
[17:28:19.994]                   NAME <- NAMES[[kk]]
[17:28:19.994]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.994]                     next
[17:28:19.994]                   args[[name]] <- ""
[17:28:19.994]                 }
[17:28:19.994]                 NAMES <- toupper(removed)
[17:28:19.994]                 for (kk in seq_along(NAMES)) {
[17:28:19.994]                   name <- removed[[kk]]
[17:28:19.994]                   NAME <- NAMES[[kk]]
[17:28:19.994]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:19.994]                     next
[17:28:19.994]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:19.994]                 }
[17:28:19.994]                 if (length(args) > 0) 
[17:28:19.994]                   base::do.call(base::Sys.setenv, args = args)
[17:28:19.994]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:19.994]             }
[17:28:19.994]             else {
[17:28:19.994]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:19.994]             }
[17:28:19.994]             {
[17:28:19.994]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:19.994]                   0L) {
[17:28:19.994]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:19.994]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:19.994]                   base::options(opts)
[17:28:19.994]                 }
[17:28:19.994]                 {
[17:28:19.994]                   {
[17:28:19.994]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:19.994]                     NULL
[17:28:19.994]                   }
[17:28:19.994]                   options(future.plan = NULL)
[17:28:19.994]                   if (is.na(NA_character_)) 
[17:28:19.994]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:19.994]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:19.994]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:19.994]                     .init = FALSE)
[17:28:19.994]                 }
[17:28:19.994]             }
[17:28:19.994]         }
[17:28:19.994]     })
[17:28:19.994]     if (TRUE) {
[17:28:19.994]         base::sink(type = "output", split = FALSE)
[17:28:19.994]         if (TRUE) {
[17:28:19.994]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:19.994]         }
[17:28:19.994]         else {
[17:28:19.994]             ...future.result["stdout"] <- base::list(NULL)
[17:28:19.994]         }
[17:28:19.994]         base::close(...future.stdout)
[17:28:19.994]         ...future.stdout <- NULL
[17:28:19.994]     }
[17:28:19.994]     ...future.result$conditions <- ...future.conditions
[17:28:19.994]     ...future.result$finished <- base::Sys.time()
[17:28:19.994]     ...future.result
[17:28:19.994] }
[17:28:19.999] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:19.999] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:19.999] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.000] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.000] MultisessionFuture started
[17:28:20.000] - Launch lazy future ... done
[17:28:20.001] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-339058'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x0000026674f50ed0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:28:20.014] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.014] - Validating connection of MultisessionFuture
[17:28:20.015] - received message: FutureResult
[17:28:20.015] - Received FutureResult
[17:28:20.015] - Erased future from FutureRegistry
[17:28:20.015] result() for ClusterFuture ...
[17:28:20.015] - result already collected: FutureResult
[17:28:20.015] result() for ClusterFuture ... done
[17:28:20.016] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.016] getGlobalsAndPackages() ...
[17:28:20.016] Searching for globals...
[17:28:20.017] - globals found: [3] '{', 'sample', 'x'
[17:28:20.017] Searching for globals ... DONE
[17:28:20.018] Resolving globals: FALSE
[17:28:20.018] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.018] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.019] - globals: [1] 'x'
[17:28:20.019] 
[17:28:20.019] getGlobalsAndPackages() ... DONE
[17:28:20.019] run() for 'Future' ...
[17:28:20.019] - state: 'created'
[17:28:20.020] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.033] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.033] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.033]   - Field: 'node'
[17:28:20.034]   - Field: 'label'
[17:28:20.034]   - Field: 'local'
[17:28:20.034]   - Field: 'owner'
[17:28:20.034]   - Field: 'envir'
[17:28:20.034]   - Field: 'workers'
[17:28:20.035]   - Field: 'packages'
[17:28:20.035]   - Field: 'gc'
[17:28:20.035]   - Field: 'conditions'
[17:28:20.035]   - Field: 'persistent'
[17:28:20.035]   - Field: 'expr'
[17:28:20.035]   - Field: 'uuid'
[17:28:20.036]   - Field: 'seed'
[17:28:20.036]   - Field: 'version'
[17:28:20.036]   - Field: 'result'
[17:28:20.038]   - Field: 'asynchronous'
[17:28:20.038]   - Field: 'calls'
[17:28:20.038]   - Field: 'globals'
[17:28:20.038]   - Field: 'stdout'
[17:28:20.039]   - Field: 'earlySignal'
[17:28:20.039]   - Field: 'lazy'
[17:28:20.039]   - Field: 'state'
[17:28:20.039] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.039] - Launch lazy future ...
[17:28:20.040] Packages needed by the future expression (n = 0): <none>
[17:28:20.040] Packages needed by future strategies (n = 0): <none>
[17:28:20.040] {
[17:28:20.040]     {
[17:28:20.040]         {
[17:28:20.040]             ...future.startTime <- base::Sys.time()
[17:28:20.040]             {
[17:28:20.040]                 {
[17:28:20.040]                   {
[17:28:20.040]                     {
[17:28:20.040]                       base::local({
[17:28:20.040]                         has_future <- base::requireNamespace("future", 
[17:28:20.040]                           quietly = TRUE)
[17:28:20.040]                         if (has_future) {
[17:28:20.040]                           ns <- base::getNamespace("future")
[17:28:20.040]                           version <- ns[[".package"]][["version"]]
[17:28:20.040]                           if (is.null(version)) 
[17:28:20.040]                             version <- utils::packageVersion("future")
[17:28:20.040]                         }
[17:28:20.040]                         else {
[17:28:20.040]                           version <- NULL
[17:28:20.040]                         }
[17:28:20.040]                         if (!has_future || version < "1.8.0") {
[17:28:20.040]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.040]                             "", base::R.version$version.string), 
[17:28:20.040]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.040]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.040]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.040]                               "release", "version")], collapse = " "), 
[17:28:20.040]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.040]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.040]                             info)
[17:28:20.040]                           info <- base::paste(info, collapse = "; ")
[17:28:20.040]                           if (!has_future) {
[17:28:20.040]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.040]                               info)
[17:28:20.040]                           }
[17:28:20.040]                           else {
[17:28:20.040]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.040]                               info, version)
[17:28:20.040]                           }
[17:28:20.040]                           base::stop(msg)
[17:28:20.040]                         }
[17:28:20.040]                       })
[17:28:20.040]                     }
[17:28:20.040]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.040]                     base::options(mc.cores = 1L)
[17:28:20.040]                   }
[17:28:20.040]                   ...future.strategy.old <- future::plan("list")
[17:28:20.040]                   options(future.plan = NULL)
[17:28:20.040]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.040]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.040]                 }
[17:28:20.040]                 ...future.workdir <- getwd()
[17:28:20.040]             }
[17:28:20.040]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.040]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.040]         }
[17:28:20.040]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.040]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.040]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.040]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.040]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.040]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.040]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.040]             base::names(...future.oldOptions))
[17:28:20.040]     }
[17:28:20.040]     if (FALSE) {
[17:28:20.040]     }
[17:28:20.040]     else {
[17:28:20.040]         if (TRUE) {
[17:28:20.040]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.040]                 open = "w")
[17:28:20.040]         }
[17:28:20.040]         else {
[17:28:20.040]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.040]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.040]         }
[17:28:20.040]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.040]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.040]             base::sink(type = "output", split = FALSE)
[17:28:20.040]             base::close(...future.stdout)
[17:28:20.040]         }, add = TRUE)
[17:28:20.040]     }
[17:28:20.040]     ...future.frame <- base::sys.nframe()
[17:28:20.040]     ...future.conditions <- base::list()
[17:28:20.040]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.040]     if (FALSE) {
[17:28:20.040]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.040]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.040]     }
[17:28:20.040]     ...future.result <- base::tryCatch({
[17:28:20.040]         base::withCallingHandlers({
[17:28:20.040]             ...future.value <- base::withVisible(base::local({
[17:28:20.040]                 ...future.makeSendCondition <- base::local({
[17:28:20.040]                   sendCondition <- NULL
[17:28:20.040]                   function(frame = 1L) {
[17:28:20.040]                     if (is.function(sendCondition)) 
[17:28:20.040]                       return(sendCondition)
[17:28:20.040]                     ns <- getNamespace("parallel")
[17:28:20.040]                     if (exists("sendData", mode = "function", 
[17:28:20.040]                       envir = ns)) {
[17:28:20.040]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.040]                         envir = ns)
[17:28:20.040]                       envir <- sys.frame(frame)
[17:28:20.040]                       master <- NULL
[17:28:20.040]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.040]                         !identical(envir, emptyenv())) {
[17:28:20.040]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.040]                           inherits = FALSE)) {
[17:28:20.040]                           master <- get("master", mode = "list", 
[17:28:20.040]                             envir = envir, inherits = FALSE)
[17:28:20.040]                           if (inherits(master, c("SOCKnode", 
[17:28:20.040]                             "SOCK0node"))) {
[17:28:20.040]                             sendCondition <<- function(cond) {
[17:28:20.040]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.040]                                 success = TRUE)
[17:28:20.040]                               parallel_sendData(master, data)
[17:28:20.040]                             }
[17:28:20.040]                             return(sendCondition)
[17:28:20.040]                           }
[17:28:20.040]                         }
[17:28:20.040]                         frame <- frame + 1L
[17:28:20.040]                         envir <- sys.frame(frame)
[17:28:20.040]                       }
[17:28:20.040]                     }
[17:28:20.040]                     sendCondition <<- function(cond) NULL
[17:28:20.040]                   }
[17:28:20.040]                 })
[17:28:20.040]                 withCallingHandlers({
[17:28:20.040]                   {
[17:28:20.040]                     sample(x, size = 1L)
[17:28:20.040]                   }
[17:28:20.040]                 }, immediateCondition = function(cond) {
[17:28:20.040]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.040]                   sendCondition(cond)
[17:28:20.040]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.040]                   {
[17:28:20.040]                     inherits <- base::inherits
[17:28:20.040]                     invokeRestart <- base::invokeRestart
[17:28:20.040]                     is.null <- base::is.null
[17:28:20.040]                     muffled <- FALSE
[17:28:20.040]                     if (inherits(cond, "message")) {
[17:28:20.040]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.040]                       if (muffled) 
[17:28:20.040]                         invokeRestart("muffleMessage")
[17:28:20.040]                     }
[17:28:20.040]                     else if (inherits(cond, "warning")) {
[17:28:20.040]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.040]                       if (muffled) 
[17:28:20.040]                         invokeRestart("muffleWarning")
[17:28:20.040]                     }
[17:28:20.040]                     else if (inherits(cond, "condition")) {
[17:28:20.040]                       if (!is.null(pattern)) {
[17:28:20.040]                         computeRestarts <- base::computeRestarts
[17:28:20.040]                         grepl <- base::grepl
[17:28:20.040]                         restarts <- computeRestarts(cond)
[17:28:20.040]                         for (restart in restarts) {
[17:28:20.040]                           name <- restart$name
[17:28:20.040]                           if (is.null(name)) 
[17:28:20.040]                             next
[17:28:20.040]                           if (!grepl(pattern, name)) 
[17:28:20.040]                             next
[17:28:20.040]                           invokeRestart(restart)
[17:28:20.040]                           muffled <- TRUE
[17:28:20.040]                           break
[17:28:20.040]                         }
[17:28:20.040]                       }
[17:28:20.040]                     }
[17:28:20.040]                     invisible(muffled)
[17:28:20.040]                   }
[17:28:20.040]                   muffleCondition(cond)
[17:28:20.040]                 })
[17:28:20.040]             }))
[17:28:20.040]             future::FutureResult(value = ...future.value$value, 
[17:28:20.040]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.040]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.040]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.040]                     ...future.globalenv.names))
[17:28:20.040]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.040]         }, condition = base::local({
[17:28:20.040]             c <- base::c
[17:28:20.040]             inherits <- base::inherits
[17:28:20.040]             invokeRestart <- base::invokeRestart
[17:28:20.040]             length <- base::length
[17:28:20.040]             list <- base::list
[17:28:20.040]             seq.int <- base::seq.int
[17:28:20.040]             signalCondition <- base::signalCondition
[17:28:20.040]             sys.calls <- base::sys.calls
[17:28:20.040]             `[[` <- base::`[[`
[17:28:20.040]             `+` <- base::`+`
[17:28:20.040]             `<<-` <- base::`<<-`
[17:28:20.040]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.040]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.040]                   3L)]
[17:28:20.040]             }
[17:28:20.040]             function(cond) {
[17:28:20.040]                 is_error <- inherits(cond, "error")
[17:28:20.040]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.040]                   NULL)
[17:28:20.040]                 if (is_error) {
[17:28:20.040]                   sessionInformation <- function() {
[17:28:20.040]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.040]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.040]                       search = base::search(), system = base::Sys.info())
[17:28:20.040]                   }
[17:28:20.040]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.040]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.040]                     cond$call), session = sessionInformation(), 
[17:28:20.040]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.040]                   signalCondition(cond)
[17:28:20.040]                 }
[17:28:20.040]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.040]                 "immediateCondition"))) {
[17:28:20.040]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.040]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.040]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.040]                   if (TRUE && !signal) {
[17:28:20.040]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.040]                     {
[17:28:20.040]                       inherits <- base::inherits
[17:28:20.040]                       invokeRestart <- base::invokeRestart
[17:28:20.040]                       is.null <- base::is.null
[17:28:20.040]                       muffled <- FALSE
[17:28:20.040]                       if (inherits(cond, "message")) {
[17:28:20.040]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.040]                         if (muffled) 
[17:28:20.040]                           invokeRestart("muffleMessage")
[17:28:20.040]                       }
[17:28:20.040]                       else if (inherits(cond, "warning")) {
[17:28:20.040]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.040]                         if (muffled) 
[17:28:20.040]                           invokeRestart("muffleWarning")
[17:28:20.040]                       }
[17:28:20.040]                       else if (inherits(cond, "condition")) {
[17:28:20.040]                         if (!is.null(pattern)) {
[17:28:20.040]                           computeRestarts <- base::computeRestarts
[17:28:20.040]                           grepl <- base::grepl
[17:28:20.040]                           restarts <- computeRestarts(cond)
[17:28:20.040]                           for (restart in restarts) {
[17:28:20.040]                             name <- restart$name
[17:28:20.040]                             if (is.null(name)) 
[17:28:20.040]                               next
[17:28:20.040]                             if (!grepl(pattern, name)) 
[17:28:20.040]                               next
[17:28:20.040]                             invokeRestart(restart)
[17:28:20.040]                             muffled <- TRUE
[17:28:20.040]                             break
[17:28:20.040]                           }
[17:28:20.040]                         }
[17:28:20.040]                       }
[17:28:20.040]                       invisible(muffled)
[17:28:20.040]                     }
[17:28:20.040]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.040]                   }
[17:28:20.040]                 }
[17:28:20.040]                 else {
[17:28:20.040]                   if (TRUE) {
[17:28:20.040]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.040]                     {
[17:28:20.040]                       inherits <- base::inherits
[17:28:20.040]                       invokeRestart <- base::invokeRestart
[17:28:20.040]                       is.null <- base::is.null
[17:28:20.040]                       muffled <- FALSE
[17:28:20.040]                       if (inherits(cond, "message")) {
[17:28:20.040]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.040]                         if (muffled) 
[17:28:20.040]                           invokeRestart("muffleMessage")
[17:28:20.040]                       }
[17:28:20.040]                       else if (inherits(cond, "warning")) {
[17:28:20.040]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.040]                         if (muffled) 
[17:28:20.040]                           invokeRestart("muffleWarning")
[17:28:20.040]                       }
[17:28:20.040]                       else if (inherits(cond, "condition")) {
[17:28:20.040]                         if (!is.null(pattern)) {
[17:28:20.040]                           computeRestarts <- base::computeRestarts
[17:28:20.040]                           grepl <- base::grepl
[17:28:20.040]                           restarts <- computeRestarts(cond)
[17:28:20.040]                           for (restart in restarts) {
[17:28:20.040]                             name <- restart$name
[17:28:20.040]                             if (is.null(name)) 
[17:28:20.040]                               next
[17:28:20.040]                             if (!grepl(pattern, name)) 
[17:28:20.040]                               next
[17:28:20.040]                             invokeRestart(restart)
[17:28:20.040]                             muffled <- TRUE
[17:28:20.040]                             break
[17:28:20.040]                           }
[17:28:20.040]                         }
[17:28:20.040]                       }
[17:28:20.040]                       invisible(muffled)
[17:28:20.040]                     }
[17:28:20.040]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.040]                   }
[17:28:20.040]                 }
[17:28:20.040]             }
[17:28:20.040]         }))
[17:28:20.040]     }, error = function(ex) {
[17:28:20.040]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.040]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.040]                 ...future.rng), started = ...future.startTime, 
[17:28:20.040]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.040]             version = "1.8"), class = "FutureResult")
[17:28:20.040]     }, finally = {
[17:28:20.040]         if (!identical(...future.workdir, getwd())) 
[17:28:20.040]             setwd(...future.workdir)
[17:28:20.040]         {
[17:28:20.040]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.040]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.040]             }
[17:28:20.040]             base::options(...future.oldOptions)
[17:28:20.040]             if (.Platform$OS.type == "windows") {
[17:28:20.040]                 old_names <- names(...future.oldEnvVars)
[17:28:20.040]                 envs <- base::Sys.getenv()
[17:28:20.040]                 names <- names(envs)
[17:28:20.040]                 common <- intersect(names, old_names)
[17:28:20.040]                 added <- setdiff(names, old_names)
[17:28:20.040]                 removed <- setdiff(old_names, names)
[17:28:20.040]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.040]                   envs[common]]
[17:28:20.040]                 NAMES <- toupper(changed)
[17:28:20.040]                 args <- list()
[17:28:20.040]                 for (kk in seq_along(NAMES)) {
[17:28:20.040]                   name <- changed[[kk]]
[17:28:20.040]                   NAME <- NAMES[[kk]]
[17:28:20.040]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.040]                     next
[17:28:20.040]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.040]                 }
[17:28:20.040]                 NAMES <- toupper(added)
[17:28:20.040]                 for (kk in seq_along(NAMES)) {
[17:28:20.040]                   name <- added[[kk]]
[17:28:20.040]                   NAME <- NAMES[[kk]]
[17:28:20.040]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.040]                     next
[17:28:20.040]                   args[[name]] <- ""
[17:28:20.040]                 }
[17:28:20.040]                 NAMES <- toupper(removed)
[17:28:20.040]                 for (kk in seq_along(NAMES)) {
[17:28:20.040]                   name <- removed[[kk]]
[17:28:20.040]                   NAME <- NAMES[[kk]]
[17:28:20.040]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.040]                     next
[17:28:20.040]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.040]                 }
[17:28:20.040]                 if (length(args) > 0) 
[17:28:20.040]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.040]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.040]             }
[17:28:20.040]             else {
[17:28:20.040]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.040]             }
[17:28:20.040]             {
[17:28:20.040]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.040]                   0L) {
[17:28:20.040]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.040]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.040]                   base::options(opts)
[17:28:20.040]                 }
[17:28:20.040]                 {
[17:28:20.040]                   {
[17:28:20.040]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.040]                     NULL
[17:28:20.040]                   }
[17:28:20.040]                   options(future.plan = NULL)
[17:28:20.040]                   if (is.na(NA_character_)) 
[17:28:20.040]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.040]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.040]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.040]                     .init = FALSE)
[17:28:20.040]                 }
[17:28:20.040]             }
[17:28:20.040]         }
[17:28:20.040]     })
[17:28:20.040]     if (TRUE) {
[17:28:20.040]         base::sink(type = "output", split = FALSE)
[17:28:20.040]         if (TRUE) {
[17:28:20.040]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.040]         }
[17:28:20.040]         else {
[17:28:20.040]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.040]         }
[17:28:20.040]         base::close(...future.stdout)
[17:28:20.040]         ...future.stdout <- NULL
[17:28:20.040]     }
[17:28:20.040]     ...future.result$conditions <- ...future.conditions
[17:28:20.040]     ...future.result$finished <- base::Sys.time()
[17:28:20.040]     ...future.result
[17:28:20.040] }
[17:28:20.045] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.045] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.046] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.046] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.047] MultisessionFuture started
[17:28:20.047] - Launch lazy future ... done
[17:28:20.047] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-679507'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x0000026674f50ed0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:28:20.062] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.062] - Validating connection of MultisessionFuture
[17:28:20.062] - received message: FutureResult
[17:28:20.063] - Received FutureResult
[17:28:20.063] - Erased future from FutureRegistry
[17:28:20.063] result() for ClusterFuture ...
[17:28:20.063] - result already collected: FutureResult
[17:28:20.063] result() for ClusterFuture ... done
[17:28:20.063] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.064] resolve() on list ...
[17:28:20.064]  recursive: 0
[17:28:20.064]  length: 4
[17:28:20.064] 
[17:28:20.064] Future #1
[17:28:20.064] result() for ClusterFuture ...
[17:28:20.065] - result already collected: FutureResult
[17:28:20.065] result() for ClusterFuture ... done
[17:28:20.065] result() for ClusterFuture ...
[17:28:20.065] - result already collected: FutureResult
[17:28:20.065] result() for ClusterFuture ... done
[17:28:20.065] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:28:20.066] - nx: 4
[17:28:20.066] - relay: TRUE
[17:28:20.066] - stdout: TRUE
[17:28:20.066] - signal: TRUE
[17:28:20.066] - resignal: FALSE
[17:28:20.066] - force: TRUE
[17:28:20.067] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:20.067] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:20.067]  - until=1
[17:28:20.067]  - relaying element #1
[17:28:20.067] result() for ClusterFuture ...
[17:28:20.067] - result already collected: FutureResult
[17:28:20.068] result() for ClusterFuture ... done
[17:28:20.068] result() for ClusterFuture ...
[17:28:20.068] - result already collected: FutureResult
[17:28:20.068] result() for ClusterFuture ... done
[17:28:20.068] result() for ClusterFuture ...
[17:28:20.068] - result already collected: FutureResult
[17:28:20.069] result() for ClusterFuture ... done
[17:28:20.069] result() for ClusterFuture ...
[17:28:20.069] - result already collected: FutureResult
[17:28:20.069] result() for ClusterFuture ... done
[17:28:20.069] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:20.069] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:20.069] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[17:28:20.070]  length: 3 (resolved future 1)
[17:28:20.070] Future #2
[17:28:20.070] result() for ClusterFuture ...
[17:28:20.070] - result already collected: FutureResult
[17:28:20.070] result() for ClusterFuture ... done
[17:28:20.070] result() for ClusterFuture ...
[17:28:20.071] - result already collected: FutureResult
[17:28:20.071] result() for ClusterFuture ... done
[17:28:20.071] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:28:20.071] - nx: 4
[17:28:20.071] - relay: TRUE
[17:28:20.072] - stdout: TRUE
[17:28:20.072] - signal: TRUE
[17:28:20.072] - resignal: FALSE
[17:28:20.072] - force: TRUE
[17:28:20.072] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:20.072] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:20.072]  - until=2
[17:28:20.073]  - relaying element #2
[17:28:20.073] result() for ClusterFuture ...
[17:28:20.073] - result already collected: FutureResult
[17:28:20.073] result() for ClusterFuture ... done
[17:28:20.073] result() for ClusterFuture ...
[17:28:20.073] - result already collected: FutureResult
[17:28:20.074] result() for ClusterFuture ... done
[17:28:20.074] result() for ClusterFuture ...
[17:28:20.074] - result already collected: FutureResult
[17:28:20.074] result() for ClusterFuture ... done
[17:28:20.074] result() for ClusterFuture ...
[17:28:20.074] - result already collected: FutureResult
[17:28:20.074] result() for ClusterFuture ... done
[17:28:20.075] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:20.075] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:20.075] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:28:20.075]  length: 2 (resolved future 2)
[17:28:20.075] Future #3
[17:28:20.075] result() for ClusterFuture ...
[17:28:20.076] - result already collected: FutureResult
[17:28:20.076] result() for ClusterFuture ... done
[17:28:20.076] result() for ClusterFuture ...
[17:28:20.076] - result already collected: FutureResult
[17:28:20.076] result() for ClusterFuture ... done
[17:28:20.077] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:28:20.077] - nx: 4
[17:28:20.077] - relay: TRUE
[17:28:20.077] - stdout: TRUE
[17:28:20.077] - signal: TRUE
[17:28:20.077] - resignal: FALSE
[17:28:20.077] - force: TRUE
[17:28:20.078] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:20.078] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:20.078]  - until=3
[17:28:20.078]  - relaying element #3
[17:28:20.078] result() for ClusterFuture ...
[17:28:20.078] - result already collected: FutureResult
[17:28:20.079] result() for ClusterFuture ... done
[17:28:20.079] result() for ClusterFuture ...
[17:28:20.079] - result already collected: FutureResult
[17:28:20.079] result() for ClusterFuture ... done
[17:28:20.079] result() for ClusterFuture ...
[17:28:20.079] - result already collected: FutureResult
[17:28:20.079] result() for ClusterFuture ... done
[17:28:20.080] result() for ClusterFuture ...
[17:28:20.080] - result already collected: FutureResult
[17:28:20.080] result() for ClusterFuture ... done
[17:28:20.080] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:20.080] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:20.080] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:28:20.081]  length: 1 (resolved future 3)
[17:28:20.081] Future #4
[17:28:20.081] result() for ClusterFuture ...
[17:28:20.081] - result already collected: FutureResult
[17:28:20.081] result() for ClusterFuture ... done
[17:28:20.081] result() for ClusterFuture ...
[17:28:20.082] - result already collected: FutureResult
[17:28:20.082] result() for ClusterFuture ... done
[17:28:20.082] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:28:20.082] - nx: 4
[17:28:20.082] - relay: TRUE
[17:28:20.082] - stdout: TRUE
[17:28:20.083] - signal: TRUE
[17:28:20.083] - resignal: FALSE
[17:28:20.083] - force: TRUE
[17:28:20.083] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:20.083] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:20.083]  - until=4
[17:28:20.084]  - relaying element #4
[17:28:20.084] result() for ClusterFuture ...
[17:28:20.084] - result already collected: FutureResult
[17:28:20.084] result() for ClusterFuture ... done
[17:28:20.084] result() for ClusterFuture ...
[17:28:20.084] - result already collected: FutureResult
[17:28:20.084] result() for ClusterFuture ... done
[17:28:20.085] result() for ClusterFuture ...
[17:28:20.085] - result already collected: FutureResult
[17:28:20.085] result() for ClusterFuture ... done
[17:28:20.085] result() for ClusterFuture ...
[17:28:20.085] - result already collected: FutureResult
[17:28:20.085] result() for ClusterFuture ... done
[17:28:20.086] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:20.086] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:20.086] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:28:20.086]  length: 0 (resolved future 4)
[17:28:20.086] Relaying remaining futures
[17:28:20.086] signalConditionsASAP(NULL, pos=0) ...
[17:28:20.087] - nx: 4
[17:28:20.087] - relay: TRUE
[17:28:20.087] - stdout: TRUE
[17:28:20.087] - signal: TRUE
[17:28:20.087] - resignal: FALSE
[17:28:20.087] - force: TRUE
[17:28:20.087] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:20.088] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:28:20.088] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:20.088] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:20.088] signalConditionsASAP(NULL, pos=0) ... done
[17:28:20.088] resolve() on list ... DONE
[17:28:20.088] result() for ClusterFuture ...
[17:28:20.089] - result already collected: FutureResult
[17:28:20.089] result() for ClusterFuture ... done
[17:28:20.089] result() for ClusterFuture ...
[17:28:20.089] - result already collected: FutureResult
[17:28:20.089] result() for ClusterFuture ... done
[17:28:20.089] result() for ClusterFuture ...
[17:28:20.090] - result already collected: FutureResult
[17:28:20.090] result() for ClusterFuture ... done
[17:28:20.090] result() for ClusterFuture ...
[17:28:20.090] - result already collected: FutureResult
[17:28:20.090] result() for ClusterFuture ... done
[17:28:20.090] result() for ClusterFuture ...
[17:28:20.091] - result already collected: FutureResult
[17:28:20.091] result() for ClusterFuture ... done
[17:28:20.091] result() for ClusterFuture ...
[17:28:20.091] - result already collected: FutureResult
[17:28:20.091] result() for ClusterFuture ... done
[17:28:20.091] result() for ClusterFuture ...
[17:28:20.091] - result already collected: FutureResult
[17:28:20.092] result() for ClusterFuture ... done
[17:28:20.092] result() for ClusterFuture ...
[17:28:20.092] - result already collected: FutureResult
[17:28:20.092] result() for ClusterFuture ... done
[[1]]
[1] 2

[[2]]
[1] 2

[[3]]
[1] 1

[[4]]
[1] 1

[17:28:20.092] getGlobalsAndPackages() ...
[17:28:20.093] Searching for globals...
[17:28:20.094] - globals found: [3] '{', 'sample', 'x'
[17:28:20.094] Searching for globals ... DONE
[17:28:20.094] Resolving globals: FALSE
[17:28:20.095] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.095] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.095] - globals: [1] 'x'
[17:28:20.095] 
[17:28:20.096] getGlobalsAndPackages() ... DONE
[17:28:20.096] run() for 'Future' ...
[17:28:20.096] - state: 'created'
[17:28:20.096] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.110] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.110] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.110]   - Field: 'node'
[17:28:20.110]   - Field: 'label'
[17:28:20.111]   - Field: 'local'
[17:28:20.111]   - Field: 'owner'
[17:28:20.111]   - Field: 'envir'
[17:28:20.111]   - Field: 'workers'
[17:28:20.111]   - Field: 'packages'
[17:28:20.111]   - Field: 'gc'
[17:28:20.112]   - Field: 'conditions'
[17:28:20.112]   - Field: 'persistent'
[17:28:20.112]   - Field: 'expr'
[17:28:20.112]   - Field: 'uuid'
[17:28:20.112]   - Field: 'seed'
[17:28:20.112]   - Field: 'version'
[17:28:20.113]   - Field: 'result'
[17:28:20.113]   - Field: 'asynchronous'
[17:28:20.113]   - Field: 'calls'
[17:28:20.113]   - Field: 'globals'
[17:28:20.113]   - Field: 'stdout'
[17:28:20.113]   - Field: 'earlySignal'
[17:28:20.114]   - Field: 'lazy'
[17:28:20.114]   - Field: 'state'
[17:28:20.114] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.114] - Launch lazy future ...
[17:28:20.115] Packages needed by the future expression (n = 0): <none>
[17:28:20.115] Packages needed by future strategies (n = 0): <none>
[17:28:20.115] {
[17:28:20.115]     {
[17:28:20.115]         {
[17:28:20.115]             ...future.startTime <- base::Sys.time()
[17:28:20.115]             {
[17:28:20.115]                 {
[17:28:20.115]                   {
[17:28:20.115]                     {
[17:28:20.115]                       base::local({
[17:28:20.115]                         has_future <- base::requireNamespace("future", 
[17:28:20.115]                           quietly = TRUE)
[17:28:20.115]                         if (has_future) {
[17:28:20.115]                           ns <- base::getNamespace("future")
[17:28:20.115]                           version <- ns[[".package"]][["version"]]
[17:28:20.115]                           if (is.null(version)) 
[17:28:20.115]                             version <- utils::packageVersion("future")
[17:28:20.115]                         }
[17:28:20.115]                         else {
[17:28:20.115]                           version <- NULL
[17:28:20.115]                         }
[17:28:20.115]                         if (!has_future || version < "1.8.0") {
[17:28:20.115]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.115]                             "", base::R.version$version.string), 
[17:28:20.115]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.115]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.115]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.115]                               "release", "version")], collapse = " "), 
[17:28:20.115]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.115]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.115]                             info)
[17:28:20.115]                           info <- base::paste(info, collapse = "; ")
[17:28:20.115]                           if (!has_future) {
[17:28:20.115]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.115]                               info)
[17:28:20.115]                           }
[17:28:20.115]                           else {
[17:28:20.115]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.115]                               info, version)
[17:28:20.115]                           }
[17:28:20.115]                           base::stop(msg)
[17:28:20.115]                         }
[17:28:20.115]                       })
[17:28:20.115]                     }
[17:28:20.115]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.115]                     base::options(mc.cores = 1L)
[17:28:20.115]                   }
[17:28:20.115]                   ...future.strategy.old <- future::plan("list")
[17:28:20.115]                   options(future.plan = NULL)
[17:28:20.115]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.115]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.115]                 }
[17:28:20.115]                 ...future.workdir <- getwd()
[17:28:20.115]             }
[17:28:20.115]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.115]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.115]         }
[17:28:20.115]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.115]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.115]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.115]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.115]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.115]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.115]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.115]             base::names(...future.oldOptions))
[17:28:20.115]     }
[17:28:20.115]     if (FALSE) {
[17:28:20.115]     }
[17:28:20.115]     else {
[17:28:20.115]         if (TRUE) {
[17:28:20.115]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.115]                 open = "w")
[17:28:20.115]         }
[17:28:20.115]         else {
[17:28:20.115]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.115]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.115]         }
[17:28:20.115]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.115]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.115]             base::sink(type = "output", split = FALSE)
[17:28:20.115]             base::close(...future.stdout)
[17:28:20.115]         }, add = TRUE)
[17:28:20.115]     }
[17:28:20.115]     ...future.frame <- base::sys.nframe()
[17:28:20.115]     ...future.conditions <- base::list()
[17:28:20.115]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.115]     if (FALSE) {
[17:28:20.115]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.115]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.115]     }
[17:28:20.115]     ...future.result <- base::tryCatch({
[17:28:20.115]         base::withCallingHandlers({
[17:28:20.115]             ...future.value <- base::withVisible(base::local({
[17:28:20.115]                 ...future.makeSendCondition <- base::local({
[17:28:20.115]                   sendCondition <- NULL
[17:28:20.115]                   function(frame = 1L) {
[17:28:20.115]                     if (is.function(sendCondition)) 
[17:28:20.115]                       return(sendCondition)
[17:28:20.115]                     ns <- getNamespace("parallel")
[17:28:20.115]                     if (exists("sendData", mode = "function", 
[17:28:20.115]                       envir = ns)) {
[17:28:20.115]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.115]                         envir = ns)
[17:28:20.115]                       envir <- sys.frame(frame)
[17:28:20.115]                       master <- NULL
[17:28:20.115]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.115]                         !identical(envir, emptyenv())) {
[17:28:20.115]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.115]                           inherits = FALSE)) {
[17:28:20.115]                           master <- get("master", mode = "list", 
[17:28:20.115]                             envir = envir, inherits = FALSE)
[17:28:20.115]                           if (inherits(master, c("SOCKnode", 
[17:28:20.115]                             "SOCK0node"))) {
[17:28:20.115]                             sendCondition <<- function(cond) {
[17:28:20.115]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.115]                                 success = TRUE)
[17:28:20.115]                               parallel_sendData(master, data)
[17:28:20.115]                             }
[17:28:20.115]                             return(sendCondition)
[17:28:20.115]                           }
[17:28:20.115]                         }
[17:28:20.115]                         frame <- frame + 1L
[17:28:20.115]                         envir <- sys.frame(frame)
[17:28:20.115]                       }
[17:28:20.115]                     }
[17:28:20.115]                     sendCondition <<- function(cond) NULL
[17:28:20.115]                   }
[17:28:20.115]                 })
[17:28:20.115]                 withCallingHandlers({
[17:28:20.115]                   {
[17:28:20.115]                     sample(x, size = 1L)
[17:28:20.115]                   }
[17:28:20.115]                 }, immediateCondition = function(cond) {
[17:28:20.115]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.115]                   sendCondition(cond)
[17:28:20.115]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.115]                   {
[17:28:20.115]                     inherits <- base::inherits
[17:28:20.115]                     invokeRestart <- base::invokeRestart
[17:28:20.115]                     is.null <- base::is.null
[17:28:20.115]                     muffled <- FALSE
[17:28:20.115]                     if (inherits(cond, "message")) {
[17:28:20.115]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.115]                       if (muffled) 
[17:28:20.115]                         invokeRestart("muffleMessage")
[17:28:20.115]                     }
[17:28:20.115]                     else if (inherits(cond, "warning")) {
[17:28:20.115]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.115]                       if (muffled) 
[17:28:20.115]                         invokeRestart("muffleWarning")
[17:28:20.115]                     }
[17:28:20.115]                     else if (inherits(cond, "condition")) {
[17:28:20.115]                       if (!is.null(pattern)) {
[17:28:20.115]                         computeRestarts <- base::computeRestarts
[17:28:20.115]                         grepl <- base::grepl
[17:28:20.115]                         restarts <- computeRestarts(cond)
[17:28:20.115]                         for (restart in restarts) {
[17:28:20.115]                           name <- restart$name
[17:28:20.115]                           if (is.null(name)) 
[17:28:20.115]                             next
[17:28:20.115]                           if (!grepl(pattern, name)) 
[17:28:20.115]                             next
[17:28:20.115]                           invokeRestart(restart)
[17:28:20.115]                           muffled <- TRUE
[17:28:20.115]                           break
[17:28:20.115]                         }
[17:28:20.115]                       }
[17:28:20.115]                     }
[17:28:20.115]                     invisible(muffled)
[17:28:20.115]                   }
[17:28:20.115]                   muffleCondition(cond)
[17:28:20.115]                 })
[17:28:20.115]             }))
[17:28:20.115]             future::FutureResult(value = ...future.value$value, 
[17:28:20.115]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.115]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.115]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.115]                     ...future.globalenv.names))
[17:28:20.115]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.115]         }, condition = base::local({
[17:28:20.115]             c <- base::c
[17:28:20.115]             inherits <- base::inherits
[17:28:20.115]             invokeRestart <- base::invokeRestart
[17:28:20.115]             length <- base::length
[17:28:20.115]             list <- base::list
[17:28:20.115]             seq.int <- base::seq.int
[17:28:20.115]             signalCondition <- base::signalCondition
[17:28:20.115]             sys.calls <- base::sys.calls
[17:28:20.115]             `[[` <- base::`[[`
[17:28:20.115]             `+` <- base::`+`
[17:28:20.115]             `<<-` <- base::`<<-`
[17:28:20.115]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.115]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.115]                   3L)]
[17:28:20.115]             }
[17:28:20.115]             function(cond) {
[17:28:20.115]                 is_error <- inherits(cond, "error")
[17:28:20.115]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.115]                   NULL)
[17:28:20.115]                 if (is_error) {
[17:28:20.115]                   sessionInformation <- function() {
[17:28:20.115]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.115]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.115]                       search = base::search(), system = base::Sys.info())
[17:28:20.115]                   }
[17:28:20.115]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.115]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.115]                     cond$call), session = sessionInformation(), 
[17:28:20.115]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.115]                   signalCondition(cond)
[17:28:20.115]                 }
[17:28:20.115]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.115]                 "immediateCondition"))) {
[17:28:20.115]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.115]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.115]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.115]                   if (TRUE && !signal) {
[17:28:20.115]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.115]                     {
[17:28:20.115]                       inherits <- base::inherits
[17:28:20.115]                       invokeRestart <- base::invokeRestart
[17:28:20.115]                       is.null <- base::is.null
[17:28:20.115]                       muffled <- FALSE
[17:28:20.115]                       if (inherits(cond, "message")) {
[17:28:20.115]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.115]                         if (muffled) 
[17:28:20.115]                           invokeRestart("muffleMessage")
[17:28:20.115]                       }
[17:28:20.115]                       else if (inherits(cond, "warning")) {
[17:28:20.115]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.115]                         if (muffled) 
[17:28:20.115]                           invokeRestart("muffleWarning")
[17:28:20.115]                       }
[17:28:20.115]                       else if (inherits(cond, "condition")) {
[17:28:20.115]                         if (!is.null(pattern)) {
[17:28:20.115]                           computeRestarts <- base::computeRestarts
[17:28:20.115]                           grepl <- base::grepl
[17:28:20.115]                           restarts <- computeRestarts(cond)
[17:28:20.115]                           for (restart in restarts) {
[17:28:20.115]                             name <- restart$name
[17:28:20.115]                             if (is.null(name)) 
[17:28:20.115]                               next
[17:28:20.115]                             if (!grepl(pattern, name)) 
[17:28:20.115]                               next
[17:28:20.115]                             invokeRestart(restart)
[17:28:20.115]                             muffled <- TRUE
[17:28:20.115]                             break
[17:28:20.115]                           }
[17:28:20.115]                         }
[17:28:20.115]                       }
[17:28:20.115]                       invisible(muffled)
[17:28:20.115]                     }
[17:28:20.115]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.115]                   }
[17:28:20.115]                 }
[17:28:20.115]                 else {
[17:28:20.115]                   if (TRUE) {
[17:28:20.115]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.115]                     {
[17:28:20.115]                       inherits <- base::inherits
[17:28:20.115]                       invokeRestart <- base::invokeRestart
[17:28:20.115]                       is.null <- base::is.null
[17:28:20.115]                       muffled <- FALSE
[17:28:20.115]                       if (inherits(cond, "message")) {
[17:28:20.115]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.115]                         if (muffled) 
[17:28:20.115]                           invokeRestart("muffleMessage")
[17:28:20.115]                       }
[17:28:20.115]                       else if (inherits(cond, "warning")) {
[17:28:20.115]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.115]                         if (muffled) 
[17:28:20.115]                           invokeRestart("muffleWarning")
[17:28:20.115]                       }
[17:28:20.115]                       else if (inherits(cond, "condition")) {
[17:28:20.115]                         if (!is.null(pattern)) {
[17:28:20.115]                           computeRestarts <- base::computeRestarts
[17:28:20.115]                           grepl <- base::grepl
[17:28:20.115]                           restarts <- computeRestarts(cond)
[17:28:20.115]                           for (restart in restarts) {
[17:28:20.115]                             name <- restart$name
[17:28:20.115]                             if (is.null(name)) 
[17:28:20.115]                               next
[17:28:20.115]                             if (!grepl(pattern, name)) 
[17:28:20.115]                               next
[17:28:20.115]                             invokeRestart(restart)
[17:28:20.115]                             muffled <- TRUE
[17:28:20.115]                             break
[17:28:20.115]                           }
[17:28:20.115]                         }
[17:28:20.115]                       }
[17:28:20.115]                       invisible(muffled)
[17:28:20.115]                     }
[17:28:20.115]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.115]                   }
[17:28:20.115]                 }
[17:28:20.115]             }
[17:28:20.115]         }))
[17:28:20.115]     }, error = function(ex) {
[17:28:20.115]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.115]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.115]                 ...future.rng), started = ...future.startTime, 
[17:28:20.115]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.115]             version = "1.8"), class = "FutureResult")
[17:28:20.115]     }, finally = {
[17:28:20.115]         if (!identical(...future.workdir, getwd())) 
[17:28:20.115]             setwd(...future.workdir)
[17:28:20.115]         {
[17:28:20.115]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.115]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.115]             }
[17:28:20.115]             base::options(...future.oldOptions)
[17:28:20.115]             if (.Platform$OS.type == "windows") {
[17:28:20.115]                 old_names <- names(...future.oldEnvVars)
[17:28:20.115]                 envs <- base::Sys.getenv()
[17:28:20.115]                 names <- names(envs)
[17:28:20.115]                 common <- intersect(names, old_names)
[17:28:20.115]                 added <- setdiff(names, old_names)
[17:28:20.115]                 removed <- setdiff(old_names, names)
[17:28:20.115]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.115]                   envs[common]]
[17:28:20.115]                 NAMES <- toupper(changed)
[17:28:20.115]                 args <- list()
[17:28:20.115]                 for (kk in seq_along(NAMES)) {
[17:28:20.115]                   name <- changed[[kk]]
[17:28:20.115]                   NAME <- NAMES[[kk]]
[17:28:20.115]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.115]                     next
[17:28:20.115]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.115]                 }
[17:28:20.115]                 NAMES <- toupper(added)
[17:28:20.115]                 for (kk in seq_along(NAMES)) {
[17:28:20.115]                   name <- added[[kk]]
[17:28:20.115]                   NAME <- NAMES[[kk]]
[17:28:20.115]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.115]                     next
[17:28:20.115]                   args[[name]] <- ""
[17:28:20.115]                 }
[17:28:20.115]                 NAMES <- toupper(removed)
[17:28:20.115]                 for (kk in seq_along(NAMES)) {
[17:28:20.115]                   name <- removed[[kk]]
[17:28:20.115]                   NAME <- NAMES[[kk]]
[17:28:20.115]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.115]                     next
[17:28:20.115]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.115]                 }
[17:28:20.115]                 if (length(args) > 0) 
[17:28:20.115]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.115]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.115]             }
[17:28:20.115]             else {
[17:28:20.115]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.115]             }
[17:28:20.115]             {
[17:28:20.115]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.115]                   0L) {
[17:28:20.115]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.115]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.115]                   base::options(opts)
[17:28:20.115]                 }
[17:28:20.115]                 {
[17:28:20.115]                   {
[17:28:20.115]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.115]                     NULL
[17:28:20.115]                   }
[17:28:20.115]                   options(future.plan = NULL)
[17:28:20.115]                   if (is.na(NA_character_)) 
[17:28:20.115]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.115]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.115]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.115]                     .init = FALSE)
[17:28:20.115]                 }
[17:28:20.115]             }
[17:28:20.115]         }
[17:28:20.115]     })
[17:28:20.115]     if (TRUE) {
[17:28:20.115]         base::sink(type = "output", split = FALSE)
[17:28:20.115]         if (TRUE) {
[17:28:20.115]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.115]         }
[17:28:20.115]         else {
[17:28:20.115]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.115]         }
[17:28:20.115]         base::close(...future.stdout)
[17:28:20.115]         ...future.stdout <- NULL
[17:28:20.115]     }
[17:28:20.115]     ...future.result$conditions <- ...future.conditions
[17:28:20.115]     ...future.result$finished <- base::Sys.time()
[17:28:20.115]     ...future.result
[17:28:20.115] }
[17:28:20.120] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.120] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.121] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.121] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.122] MultisessionFuture started
[17:28:20.122] - Launch lazy future ... done
[17:28:20.122] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-224023'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x00000266710b8668
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:28:20.136] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.137] - Validating connection of MultisessionFuture
[17:28:20.137] - received message: FutureResult
[17:28:20.137] - Received FutureResult
[17:28:20.137] - Erased future from FutureRegistry
[17:28:20.137] result() for ClusterFuture ...
[17:28:20.138] - result already collected: FutureResult
[17:28:20.138] result() for ClusterFuture ... done
[17:28:20.138] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.138] getGlobalsAndPackages() ...
[17:28:20.138] Searching for globals...
[17:28:20.140] - globals found: [3] '{', 'sample', 'x'
[17:28:20.140] Searching for globals ... DONE
[17:28:20.140] Resolving globals: FALSE
[17:28:20.140] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.141] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.141] - globals: [1] 'x'
[17:28:20.141] 
[17:28:20.141] getGlobalsAndPackages() ... DONE
[17:28:20.142] run() for 'Future' ...
[17:28:20.142] - state: 'created'
[17:28:20.142] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.155] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.156] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.156]   - Field: 'node'
[17:28:20.156]   - Field: 'label'
[17:28:20.156]   - Field: 'local'
[17:28:20.156]   - Field: 'owner'
[17:28:20.157]   - Field: 'envir'
[17:28:20.157]   - Field: 'workers'
[17:28:20.157]   - Field: 'packages'
[17:28:20.157]   - Field: 'gc'
[17:28:20.157]   - Field: 'conditions'
[17:28:20.157]   - Field: 'persistent'
[17:28:20.158]   - Field: 'expr'
[17:28:20.158]   - Field: 'uuid'
[17:28:20.158]   - Field: 'seed'
[17:28:20.158]   - Field: 'version'
[17:28:20.158]   - Field: 'result'
[17:28:20.158]   - Field: 'asynchronous'
[17:28:20.159]   - Field: 'calls'
[17:28:20.159]   - Field: 'globals'
[17:28:20.159]   - Field: 'stdout'
[17:28:20.159]   - Field: 'earlySignal'
[17:28:20.159]   - Field: 'lazy'
[17:28:20.160]   - Field: 'state'
[17:28:20.160] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.160] - Launch lazy future ...
[17:28:20.160] Packages needed by the future expression (n = 0): <none>
[17:28:20.160] Packages needed by future strategies (n = 0): <none>
[17:28:20.161] {
[17:28:20.161]     {
[17:28:20.161]         {
[17:28:20.161]             ...future.startTime <- base::Sys.time()
[17:28:20.161]             {
[17:28:20.161]                 {
[17:28:20.161]                   {
[17:28:20.161]                     {
[17:28:20.161]                       base::local({
[17:28:20.161]                         has_future <- base::requireNamespace("future", 
[17:28:20.161]                           quietly = TRUE)
[17:28:20.161]                         if (has_future) {
[17:28:20.161]                           ns <- base::getNamespace("future")
[17:28:20.161]                           version <- ns[[".package"]][["version"]]
[17:28:20.161]                           if (is.null(version)) 
[17:28:20.161]                             version <- utils::packageVersion("future")
[17:28:20.161]                         }
[17:28:20.161]                         else {
[17:28:20.161]                           version <- NULL
[17:28:20.161]                         }
[17:28:20.161]                         if (!has_future || version < "1.8.0") {
[17:28:20.161]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.161]                             "", base::R.version$version.string), 
[17:28:20.161]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.161]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.161]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.161]                               "release", "version")], collapse = " "), 
[17:28:20.161]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.161]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.161]                             info)
[17:28:20.161]                           info <- base::paste(info, collapse = "; ")
[17:28:20.161]                           if (!has_future) {
[17:28:20.161]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.161]                               info)
[17:28:20.161]                           }
[17:28:20.161]                           else {
[17:28:20.161]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.161]                               info, version)
[17:28:20.161]                           }
[17:28:20.161]                           base::stop(msg)
[17:28:20.161]                         }
[17:28:20.161]                       })
[17:28:20.161]                     }
[17:28:20.161]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.161]                     base::options(mc.cores = 1L)
[17:28:20.161]                   }
[17:28:20.161]                   ...future.strategy.old <- future::plan("list")
[17:28:20.161]                   options(future.plan = NULL)
[17:28:20.161]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.161]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.161]                 }
[17:28:20.161]                 ...future.workdir <- getwd()
[17:28:20.161]             }
[17:28:20.161]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.161]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.161]         }
[17:28:20.161]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.161]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.161]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.161]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.161]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.161]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.161]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.161]             base::names(...future.oldOptions))
[17:28:20.161]     }
[17:28:20.161]     if (FALSE) {
[17:28:20.161]     }
[17:28:20.161]     else {
[17:28:20.161]         if (TRUE) {
[17:28:20.161]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.161]                 open = "w")
[17:28:20.161]         }
[17:28:20.161]         else {
[17:28:20.161]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.161]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.161]         }
[17:28:20.161]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.161]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.161]             base::sink(type = "output", split = FALSE)
[17:28:20.161]             base::close(...future.stdout)
[17:28:20.161]         }, add = TRUE)
[17:28:20.161]     }
[17:28:20.161]     ...future.frame <- base::sys.nframe()
[17:28:20.161]     ...future.conditions <- base::list()
[17:28:20.161]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.161]     if (FALSE) {
[17:28:20.161]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.161]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.161]     }
[17:28:20.161]     ...future.result <- base::tryCatch({
[17:28:20.161]         base::withCallingHandlers({
[17:28:20.161]             ...future.value <- base::withVisible(base::local({
[17:28:20.161]                 ...future.makeSendCondition <- base::local({
[17:28:20.161]                   sendCondition <- NULL
[17:28:20.161]                   function(frame = 1L) {
[17:28:20.161]                     if (is.function(sendCondition)) 
[17:28:20.161]                       return(sendCondition)
[17:28:20.161]                     ns <- getNamespace("parallel")
[17:28:20.161]                     if (exists("sendData", mode = "function", 
[17:28:20.161]                       envir = ns)) {
[17:28:20.161]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.161]                         envir = ns)
[17:28:20.161]                       envir <- sys.frame(frame)
[17:28:20.161]                       master <- NULL
[17:28:20.161]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.161]                         !identical(envir, emptyenv())) {
[17:28:20.161]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.161]                           inherits = FALSE)) {
[17:28:20.161]                           master <- get("master", mode = "list", 
[17:28:20.161]                             envir = envir, inherits = FALSE)
[17:28:20.161]                           if (inherits(master, c("SOCKnode", 
[17:28:20.161]                             "SOCK0node"))) {
[17:28:20.161]                             sendCondition <<- function(cond) {
[17:28:20.161]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.161]                                 success = TRUE)
[17:28:20.161]                               parallel_sendData(master, data)
[17:28:20.161]                             }
[17:28:20.161]                             return(sendCondition)
[17:28:20.161]                           }
[17:28:20.161]                         }
[17:28:20.161]                         frame <- frame + 1L
[17:28:20.161]                         envir <- sys.frame(frame)
[17:28:20.161]                       }
[17:28:20.161]                     }
[17:28:20.161]                     sendCondition <<- function(cond) NULL
[17:28:20.161]                   }
[17:28:20.161]                 })
[17:28:20.161]                 withCallingHandlers({
[17:28:20.161]                   {
[17:28:20.161]                     sample(x, size = 1L)
[17:28:20.161]                   }
[17:28:20.161]                 }, immediateCondition = function(cond) {
[17:28:20.161]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.161]                   sendCondition(cond)
[17:28:20.161]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.161]                   {
[17:28:20.161]                     inherits <- base::inherits
[17:28:20.161]                     invokeRestart <- base::invokeRestart
[17:28:20.161]                     is.null <- base::is.null
[17:28:20.161]                     muffled <- FALSE
[17:28:20.161]                     if (inherits(cond, "message")) {
[17:28:20.161]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.161]                       if (muffled) 
[17:28:20.161]                         invokeRestart("muffleMessage")
[17:28:20.161]                     }
[17:28:20.161]                     else if (inherits(cond, "warning")) {
[17:28:20.161]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.161]                       if (muffled) 
[17:28:20.161]                         invokeRestart("muffleWarning")
[17:28:20.161]                     }
[17:28:20.161]                     else if (inherits(cond, "condition")) {
[17:28:20.161]                       if (!is.null(pattern)) {
[17:28:20.161]                         computeRestarts <- base::computeRestarts
[17:28:20.161]                         grepl <- base::grepl
[17:28:20.161]                         restarts <- computeRestarts(cond)
[17:28:20.161]                         for (restart in restarts) {
[17:28:20.161]                           name <- restart$name
[17:28:20.161]                           if (is.null(name)) 
[17:28:20.161]                             next
[17:28:20.161]                           if (!grepl(pattern, name)) 
[17:28:20.161]                             next
[17:28:20.161]                           invokeRestart(restart)
[17:28:20.161]                           muffled <- TRUE
[17:28:20.161]                           break
[17:28:20.161]                         }
[17:28:20.161]                       }
[17:28:20.161]                     }
[17:28:20.161]                     invisible(muffled)
[17:28:20.161]                   }
[17:28:20.161]                   muffleCondition(cond)
[17:28:20.161]                 })
[17:28:20.161]             }))
[17:28:20.161]             future::FutureResult(value = ...future.value$value, 
[17:28:20.161]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.161]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.161]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.161]                     ...future.globalenv.names))
[17:28:20.161]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.161]         }, condition = base::local({
[17:28:20.161]             c <- base::c
[17:28:20.161]             inherits <- base::inherits
[17:28:20.161]             invokeRestart <- base::invokeRestart
[17:28:20.161]             length <- base::length
[17:28:20.161]             list <- base::list
[17:28:20.161]             seq.int <- base::seq.int
[17:28:20.161]             signalCondition <- base::signalCondition
[17:28:20.161]             sys.calls <- base::sys.calls
[17:28:20.161]             `[[` <- base::`[[`
[17:28:20.161]             `+` <- base::`+`
[17:28:20.161]             `<<-` <- base::`<<-`
[17:28:20.161]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.161]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.161]                   3L)]
[17:28:20.161]             }
[17:28:20.161]             function(cond) {
[17:28:20.161]                 is_error <- inherits(cond, "error")
[17:28:20.161]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.161]                   NULL)
[17:28:20.161]                 if (is_error) {
[17:28:20.161]                   sessionInformation <- function() {
[17:28:20.161]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.161]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.161]                       search = base::search(), system = base::Sys.info())
[17:28:20.161]                   }
[17:28:20.161]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.161]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.161]                     cond$call), session = sessionInformation(), 
[17:28:20.161]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.161]                   signalCondition(cond)
[17:28:20.161]                 }
[17:28:20.161]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.161]                 "immediateCondition"))) {
[17:28:20.161]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.161]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.161]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.161]                   if (TRUE && !signal) {
[17:28:20.161]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.161]                     {
[17:28:20.161]                       inherits <- base::inherits
[17:28:20.161]                       invokeRestart <- base::invokeRestart
[17:28:20.161]                       is.null <- base::is.null
[17:28:20.161]                       muffled <- FALSE
[17:28:20.161]                       if (inherits(cond, "message")) {
[17:28:20.161]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.161]                         if (muffled) 
[17:28:20.161]                           invokeRestart("muffleMessage")
[17:28:20.161]                       }
[17:28:20.161]                       else if (inherits(cond, "warning")) {
[17:28:20.161]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.161]                         if (muffled) 
[17:28:20.161]                           invokeRestart("muffleWarning")
[17:28:20.161]                       }
[17:28:20.161]                       else if (inherits(cond, "condition")) {
[17:28:20.161]                         if (!is.null(pattern)) {
[17:28:20.161]                           computeRestarts <- base::computeRestarts
[17:28:20.161]                           grepl <- base::grepl
[17:28:20.161]                           restarts <- computeRestarts(cond)
[17:28:20.161]                           for (restart in restarts) {
[17:28:20.161]                             name <- restart$name
[17:28:20.161]                             if (is.null(name)) 
[17:28:20.161]                               next
[17:28:20.161]                             if (!grepl(pattern, name)) 
[17:28:20.161]                               next
[17:28:20.161]                             invokeRestart(restart)
[17:28:20.161]                             muffled <- TRUE
[17:28:20.161]                             break
[17:28:20.161]                           }
[17:28:20.161]                         }
[17:28:20.161]                       }
[17:28:20.161]                       invisible(muffled)
[17:28:20.161]                     }
[17:28:20.161]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.161]                   }
[17:28:20.161]                 }
[17:28:20.161]                 else {
[17:28:20.161]                   if (TRUE) {
[17:28:20.161]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.161]                     {
[17:28:20.161]                       inherits <- base::inherits
[17:28:20.161]                       invokeRestart <- base::invokeRestart
[17:28:20.161]                       is.null <- base::is.null
[17:28:20.161]                       muffled <- FALSE
[17:28:20.161]                       if (inherits(cond, "message")) {
[17:28:20.161]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.161]                         if (muffled) 
[17:28:20.161]                           invokeRestart("muffleMessage")
[17:28:20.161]                       }
[17:28:20.161]                       else if (inherits(cond, "warning")) {
[17:28:20.161]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.161]                         if (muffled) 
[17:28:20.161]                           invokeRestart("muffleWarning")
[17:28:20.161]                       }
[17:28:20.161]                       else if (inherits(cond, "condition")) {
[17:28:20.161]                         if (!is.null(pattern)) {
[17:28:20.161]                           computeRestarts <- base::computeRestarts
[17:28:20.161]                           grepl <- base::grepl
[17:28:20.161]                           restarts <- computeRestarts(cond)
[17:28:20.161]                           for (restart in restarts) {
[17:28:20.161]                             name <- restart$name
[17:28:20.161]                             if (is.null(name)) 
[17:28:20.161]                               next
[17:28:20.161]                             if (!grepl(pattern, name)) 
[17:28:20.161]                               next
[17:28:20.161]                             invokeRestart(restart)
[17:28:20.161]                             muffled <- TRUE
[17:28:20.161]                             break
[17:28:20.161]                           }
[17:28:20.161]                         }
[17:28:20.161]                       }
[17:28:20.161]                       invisible(muffled)
[17:28:20.161]                     }
[17:28:20.161]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.161]                   }
[17:28:20.161]                 }
[17:28:20.161]             }
[17:28:20.161]         }))
[17:28:20.161]     }, error = function(ex) {
[17:28:20.161]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.161]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.161]                 ...future.rng), started = ...future.startTime, 
[17:28:20.161]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.161]             version = "1.8"), class = "FutureResult")
[17:28:20.161]     }, finally = {
[17:28:20.161]         if (!identical(...future.workdir, getwd())) 
[17:28:20.161]             setwd(...future.workdir)
[17:28:20.161]         {
[17:28:20.161]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.161]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.161]             }
[17:28:20.161]             base::options(...future.oldOptions)
[17:28:20.161]             if (.Platform$OS.type == "windows") {
[17:28:20.161]                 old_names <- names(...future.oldEnvVars)
[17:28:20.161]                 envs <- base::Sys.getenv()
[17:28:20.161]                 names <- names(envs)
[17:28:20.161]                 common <- intersect(names, old_names)
[17:28:20.161]                 added <- setdiff(names, old_names)
[17:28:20.161]                 removed <- setdiff(old_names, names)
[17:28:20.161]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.161]                   envs[common]]
[17:28:20.161]                 NAMES <- toupper(changed)
[17:28:20.161]                 args <- list()
[17:28:20.161]                 for (kk in seq_along(NAMES)) {
[17:28:20.161]                   name <- changed[[kk]]
[17:28:20.161]                   NAME <- NAMES[[kk]]
[17:28:20.161]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.161]                     next
[17:28:20.161]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.161]                 }
[17:28:20.161]                 NAMES <- toupper(added)
[17:28:20.161]                 for (kk in seq_along(NAMES)) {
[17:28:20.161]                   name <- added[[kk]]
[17:28:20.161]                   NAME <- NAMES[[kk]]
[17:28:20.161]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.161]                     next
[17:28:20.161]                   args[[name]] <- ""
[17:28:20.161]                 }
[17:28:20.161]                 NAMES <- toupper(removed)
[17:28:20.161]                 for (kk in seq_along(NAMES)) {
[17:28:20.161]                   name <- removed[[kk]]
[17:28:20.161]                   NAME <- NAMES[[kk]]
[17:28:20.161]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.161]                     next
[17:28:20.161]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.161]                 }
[17:28:20.161]                 if (length(args) > 0) 
[17:28:20.161]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.161]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.161]             }
[17:28:20.161]             else {
[17:28:20.161]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.161]             }
[17:28:20.161]             {
[17:28:20.161]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.161]                   0L) {
[17:28:20.161]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.161]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.161]                   base::options(opts)
[17:28:20.161]                 }
[17:28:20.161]                 {
[17:28:20.161]                   {
[17:28:20.161]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.161]                     NULL
[17:28:20.161]                   }
[17:28:20.161]                   options(future.plan = NULL)
[17:28:20.161]                   if (is.na(NA_character_)) 
[17:28:20.161]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.161]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.161]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.161]                     .init = FALSE)
[17:28:20.161]                 }
[17:28:20.161]             }
[17:28:20.161]         }
[17:28:20.161]     })
[17:28:20.161]     if (TRUE) {
[17:28:20.161]         base::sink(type = "output", split = FALSE)
[17:28:20.161]         if (TRUE) {
[17:28:20.161]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.161]         }
[17:28:20.161]         else {
[17:28:20.161]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.161]         }
[17:28:20.161]         base::close(...future.stdout)
[17:28:20.161]         ...future.stdout <- NULL
[17:28:20.161]     }
[17:28:20.161]     ...future.result$conditions <- ...future.conditions
[17:28:20.161]     ...future.result$finished <- base::Sys.time()
[17:28:20.161]     ...future.result
[17:28:20.161] }
[17:28:20.166] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.166] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.166] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.167] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.167] MultisessionFuture started
[17:28:20.167] - Launch lazy future ... done
[17:28:20.168] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-916995'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x00000266710b8668
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:28:20.181] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.181] - Validating connection of MultisessionFuture
[17:28:20.181] - received message: FutureResult
[17:28:20.182] - Received FutureResult
[17:28:20.182] - Erased future from FutureRegistry
[17:28:20.182] result() for ClusterFuture ...
[17:28:20.182] - result already collected: FutureResult
[17:28:20.182] result() for ClusterFuture ... done
[17:28:20.182] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.183] getGlobalsAndPackages() ...
[17:28:20.183] Searching for globals...
[17:28:20.184] - globals found: [3] '{', 'sample', 'x'
[17:28:20.184] Searching for globals ... DONE
[17:28:20.184] Resolving globals: FALSE
[17:28:20.185] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.185] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.185] - globals: [1] 'x'
[17:28:20.186] 
[17:28:20.186] getGlobalsAndPackages() ... DONE
[17:28:20.186] run() for 'Future' ...
[17:28:20.186] - state: 'created'
[17:28:20.187] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.200] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.200] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.200]   - Field: 'node'
[17:28:20.200]   - Field: 'label'
[17:28:20.201]   - Field: 'local'
[17:28:20.201]   - Field: 'owner'
[17:28:20.201]   - Field: 'envir'
[17:28:20.201]   - Field: 'workers'
[17:28:20.201]   - Field: 'packages'
[17:28:20.201]   - Field: 'gc'
[17:28:20.202]   - Field: 'conditions'
[17:28:20.202]   - Field: 'persistent'
[17:28:20.202]   - Field: 'expr'
[17:28:20.202]   - Field: 'uuid'
[17:28:20.203]   - Field: 'seed'
[17:28:20.203]   - Field: 'version'
[17:28:20.203]   - Field: 'result'
[17:28:20.203]   - Field: 'asynchronous'
[17:28:20.203]   - Field: 'calls'
[17:28:20.203]   - Field: 'globals'
[17:28:20.204]   - Field: 'stdout'
[17:28:20.204]   - Field: 'earlySignal'
[17:28:20.204]   - Field: 'lazy'
[17:28:20.204]   - Field: 'state'
[17:28:20.204] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.204] - Launch lazy future ...
[17:28:20.205] Packages needed by the future expression (n = 0): <none>
[17:28:20.205] Packages needed by future strategies (n = 0): <none>
[17:28:20.206] {
[17:28:20.206]     {
[17:28:20.206]         {
[17:28:20.206]             ...future.startTime <- base::Sys.time()
[17:28:20.206]             {
[17:28:20.206]                 {
[17:28:20.206]                   {
[17:28:20.206]                     {
[17:28:20.206]                       base::local({
[17:28:20.206]                         has_future <- base::requireNamespace("future", 
[17:28:20.206]                           quietly = TRUE)
[17:28:20.206]                         if (has_future) {
[17:28:20.206]                           ns <- base::getNamespace("future")
[17:28:20.206]                           version <- ns[[".package"]][["version"]]
[17:28:20.206]                           if (is.null(version)) 
[17:28:20.206]                             version <- utils::packageVersion("future")
[17:28:20.206]                         }
[17:28:20.206]                         else {
[17:28:20.206]                           version <- NULL
[17:28:20.206]                         }
[17:28:20.206]                         if (!has_future || version < "1.8.0") {
[17:28:20.206]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.206]                             "", base::R.version$version.string), 
[17:28:20.206]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.206]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.206]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.206]                               "release", "version")], collapse = " "), 
[17:28:20.206]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.206]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.206]                             info)
[17:28:20.206]                           info <- base::paste(info, collapse = "; ")
[17:28:20.206]                           if (!has_future) {
[17:28:20.206]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.206]                               info)
[17:28:20.206]                           }
[17:28:20.206]                           else {
[17:28:20.206]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.206]                               info, version)
[17:28:20.206]                           }
[17:28:20.206]                           base::stop(msg)
[17:28:20.206]                         }
[17:28:20.206]                       })
[17:28:20.206]                     }
[17:28:20.206]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.206]                     base::options(mc.cores = 1L)
[17:28:20.206]                   }
[17:28:20.206]                   ...future.strategy.old <- future::plan("list")
[17:28:20.206]                   options(future.plan = NULL)
[17:28:20.206]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.206]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.206]                 }
[17:28:20.206]                 ...future.workdir <- getwd()
[17:28:20.206]             }
[17:28:20.206]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.206]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.206]         }
[17:28:20.206]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.206]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.206]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.206]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.206]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.206]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.206]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.206]             base::names(...future.oldOptions))
[17:28:20.206]     }
[17:28:20.206]     if (FALSE) {
[17:28:20.206]     }
[17:28:20.206]     else {
[17:28:20.206]         if (TRUE) {
[17:28:20.206]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.206]                 open = "w")
[17:28:20.206]         }
[17:28:20.206]         else {
[17:28:20.206]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.206]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.206]         }
[17:28:20.206]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.206]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.206]             base::sink(type = "output", split = FALSE)
[17:28:20.206]             base::close(...future.stdout)
[17:28:20.206]         }, add = TRUE)
[17:28:20.206]     }
[17:28:20.206]     ...future.frame <- base::sys.nframe()
[17:28:20.206]     ...future.conditions <- base::list()
[17:28:20.206]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.206]     if (FALSE) {
[17:28:20.206]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.206]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.206]     }
[17:28:20.206]     ...future.result <- base::tryCatch({
[17:28:20.206]         base::withCallingHandlers({
[17:28:20.206]             ...future.value <- base::withVisible(base::local({
[17:28:20.206]                 ...future.makeSendCondition <- base::local({
[17:28:20.206]                   sendCondition <- NULL
[17:28:20.206]                   function(frame = 1L) {
[17:28:20.206]                     if (is.function(sendCondition)) 
[17:28:20.206]                       return(sendCondition)
[17:28:20.206]                     ns <- getNamespace("parallel")
[17:28:20.206]                     if (exists("sendData", mode = "function", 
[17:28:20.206]                       envir = ns)) {
[17:28:20.206]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.206]                         envir = ns)
[17:28:20.206]                       envir <- sys.frame(frame)
[17:28:20.206]                       master <- NULL
[17:28:20.206]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.206]                         !identical(envir, emptyenv())) {
[17:28:20.206]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.206]                           inherits = FALSE)) {
[17:28:20.206]                           master <- get("master", mode = "list", 
[17:28:20.206]                             envir = envir, inherits = FALSE)
[17:28:20.206]                           if (inherits(master, c("SOCKnode", 
[17:28:20.206]                             "SOCK0node"))) {
[17:28:20.206]                             sendCondition <<- function(cond) {
[17:28:20.206]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.206]                                 success = TRUE)
[17:28:20.206]                               parallel_sendData(master, data)
[17:28:20.206]                             }
[17:28:20.206]                             return(sendCondition)
[17:28:20.206]                           }
[17:28:20.206]                         }
[17:28:20.206]                         frame <- frame + 1L
[17:28:20.206]                         envir <- sys.frame(frame)
[17:28:20.206]                       }
[17:28:20.206]                     }
[17:28:20.206]                     sendCondition <<- function(cond) NULL
[17:28:20.206]                   }
[17:28:20.206]                 })
[17:28:20.206]                 withCallingHandlers({
[17:28:20.206]                   {
[17:28:20.206]                     sample(x, size = 1L)
[17:28:20.206]                   }
[17:28:20.206]                 }, immediateCondition = function(cond) {
[17:28:20.206]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.206]                   sendCondition(cond)
[17:28:20.206]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.206]                   {
[17:28:20.206]                     inherits <- base::inherits
[17:28:20.206]                     invokeRestart <- base::invokeRestart
[17:28:20.206]                     is.null <- base::is.null
[17:28:20.206]                     muffled <- FALSE
[17:28:20.206]                     if (inherits(cond, "message")) {
[17:28:20.206]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.206]                       if (muffled) 
[17:28:20.206]                         invokeRestart("muffleMessage")
[17:28:20.206]                     }
[17:28:20.206]                     else if (inherits(cond, "warning")) {
[17:28:20.206]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.206]                       if (muffled) 
[17:28:20.206]                         invokeRestart("muffleWarning")
[17:28:20.206]                     }
[17:28:20.206]                     else if (inherits(cond, "condition")) {
[17:28:20.206]                       if (!is.null(pattern)) {
[17:28:20.206]                         computeRestarts <- base::computeRestarts
[17:28:20.206]                         grepl <- base::grepl
[17:28:20.206]                         restarts <- computeRestarts(cond)
[17:28:20.206]                         for (restart in restarts) {
[17:28:20.206]                           name <- restart$name
[17:28:20.206]                           if (is.null(name)) 
[17:28:20.206]                             next
[17:28:20.206]                           if (!grepl(pattern, name)) 
[17:28:20.206]                             next
[17:28:20.206]                           invokeRestart(restart)
[17:28:20.206]                           muffled <- TRUE
[17:28:20.206]                           break
[17:28:20.206]                         }
[17:28:20.206]                       }
[17:28:20.206]                     }
[17:28:20.206]                     invisible(muffled)
[17:28:20.206]                   }
[17:28:20.206]                   muffleCondition(cond)
[17:28:20.206]                 })
[17:28:20.206]             }))
[17:28:20.206]             future::FutureResult(value = ...future.value$value, 
[17:28:20.206]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.206]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.206]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.206]                     ...future.globalenv.names))
[17:28:20.206]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.206]         }, condition = base::local({
[17:28:20.206]             c <- base::c
[17:28:20.206]             inherits <- base::inherits
[17:28:20.206]             invokeRestart <- base::invokeRestart
[17:28:20.206]             length <- base::length
[17:28:20.206]             list <- base::list
[17:28:20.206]             seq.int <- base::seq.int
[17:28:20.206]             signalCondition <- base::signalCondition
[17:28:20.206]             sys.calls <- base::sys.calls
[17:28:20.206]             `[[` <- base::`[[`
[17:28:20.206]             `+` <- base::`+`
[17:28:20.206]             `<<-` <- base::`<<-`
[17:28:20.206]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.206]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.206]                   3L)]
[17:28:20.206]             }
[17:28:20.206]             function(cond) {
[17:28:20.206]                 is_error <- inherits(cond, "error")
[17:28:20.206]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.206]                   NULL)
[17:28:20.206]                 if (is_error) {
[17:28:20.206]                   sessionInformation <- function() {
[17:28:20.206]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.206]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.206]                       search = base::search(), system = base::Sys.info())
[17:28:20.206]                   }
[17:28:20.206]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.206]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.206]                     cond$call), session = sessionInformation(), 
[17:28:20.206]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.206]                   signalCondition(cond)
[17:28:20.206]                 }
[17:28:20.206]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.206]                 "immediateCondition"))) {
[17:28:20.206]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.206]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.206]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.206]                   if (TRUE && !signal) {
[17:28:20.206]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.206]                     {
[17:28:20.206]                       inherits <- base::inherits
[17:28:20.206]                       invokeRestart <- base::invokeRestart
[17:28:20.206]                       is.null <- base::is.null
[17:28:20.206]                       muffled <- FALSE
[17:28:20.206]                       if (inherits(cond, "message")) {
[17:28:20.206]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.206]                         if (muffled) 
[17:28:20.206]                           invokeRestart("muffleMessage")
[17:28:20.206]                       }
[17:28:20.206]                       else if (inherits(cond, "warning")) {
[17:28:20.206]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.206]                         if (muffled) 
[17:28:20.206]                           invokeRestart("muffleWarning")
[17:28:20.206]                       }
[17:28:20.206]                       else if (inherits(cond, "condition")) {
[17:28:20.206]                         if (!is.null(pattern)) {
[17:28:20.206]                           computeRestarts <- base::computeRestarts
[17:28:20.206]                           grepl <- base::grepl
[17:28:20.206]                           restarts <- computeRestarts(cond)
[17:28:20.206]                           for (restart in restarts) {
[17:28:20.206]                             name <- restart$name
[17:28:20.206]                             if (is.null(name)) 
[17:28:20.206]                               next
[17:28:20.206]                             if (!grepl(pattern, name)) 
[17:28:20.206]                               next
[17:28:20.206]                             invokeRestart(restart)
[17:28:20.206]                             muffled <- TRUE
[17:28:20.206]                             break
[17:28:20.206]                           }
[17:28:20.206]                         }
[17:28:20.206]                       }
[17:28:20.206]                       invisible(muffled)
[17:28:20.206]                     }
[17:28:20.206]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.206]                   }
[17:28:20.206]                 }
[17:28:20.206]                 else {
[17:28:20.206]                   if (TRUE) {
[17:28:20.206]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.206]                     {
[17:28:20.206]                       inherits <- base::inherits
[17:28:20.206]                       invokeRestart <- base::invokeRestart
[17:28:20.206]                       is.null <- base::is.null
[17:28:20.206]                       muffled <- FALSE
[17:28:20.206]                       if (inherits(cond, "message")) {
[17:28:20.206]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.206]                         if (muffled) 
[17:28:20.206]                           invokeRestart("muffleMessage")
[17:28:20.206]                       }
[17:28:20.206]                       else if (inherits(cond, "warning")) {
[17:28:20.206]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.206]                         if (muffled) 
[17:28:20.206]                           invokeRestart("muffleWarning")
[17:28:20.206]                       }
[17:28:20.206]                       else if (inherits(cond, "condition")) {
[17:28:20.206]                         if (!is.null(pattern)) {
[17:28:20.206]                           computeRestarts <- base::computeRestarts
[17:28:20.206]                           grepl <- base::grepl
[17:28:20.206]                           restarts <- computeRestarts(cond)
[17:28:20.206]                           for (restart in restarts) {
[17:28:20.206]                             name <- restart$name
[17:28:20.206]                             if (is.null(name)) 
[17:28:20.206]                               next
[17:28:20.206]                             if (!grepl(pattern, name)) 
[17:28:20.206]                               next
[17:28:20.206]                             invokeRestart(restart)
[17:28:20.206]                             muffled <- TRUE
[17:28:20.206]                             break
[17:28:20.206]                           }
[17:28:20.206]                         }
[17:28:20.206]                       }
[17:28:20.206]                       invisible(muffled)
[17:28:20.206]                     }
[17:28:20.206]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.206]                   }
[17:28:20.206]                 }
[17:28:20.206]             }
[17:28:20.206]         }))
[17:28:20.206]     }, error = function(ex) {
[17:28:20.206]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.206]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.206]                 ...future.rng), started = ...future.startTime, 
[17:28:20.206]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.206]             version = "1.8"), class = "FutureResult")
[17:28:20.206]     }, finally = {
[17:28:20.206]         if (!identical(...future.workdir, getwd())) 
[17:28:20.206]             setwd(...future.workdir)
[17:28:20.206]         {
[17:28:20.206]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.206]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.206]             }
[17:28:20.206]             base::options(...future.oldOptions)
[17:28:20.206]             if (.Platform$OS.type == "windows") {
[17:28:20.206]                 old_names <- names(...future.oldEnvVars)
[17:28:20.206]                 envs <- base::Sys.getenv()
[17:28:20.206]                 names <- names(envs)
[17:28:20.206]                 common <- intersect(names, old_names)
[17:28:20.206]                 added <- setdiff(names, old_names)
[17:28:20.206]                 removed <- setdiff(old_names, names)
[17:28:20.206]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.206]                   envs[common]]
[17:28:20.206]                 NAMES <- toupper(changed)
[17:28:20.206]                 args <- list()
[17:28:20.206]                 for (kk in seq_along(NAMES)) {
[17:28:20.206]                   name <- changed[[kk]]
[17:28:20.206]                   NAME <- NAMES[[kk]]
[17:28:20.206]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.206]                     next
[17:28:20.206]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.206]                 }
[17:28:20.206]                 NAMES <- toupper(added)
[17:28:20.206]                 for (kk in seq_along(NAMES)) {
[17:28:20.206]                   name <- added[[kk]]
[17:28:20.206]                   NAME <- NAMES[[kk]]
[17:28:20.206]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.206]                     next
[17:28:20.206]                   args[[name]] <- ""
[17:28:20.206]                 }
[17:28:20.206]                 NAMES <- toupper(removed)
[17:28:20.206]                 for (kk in seq_along(NAMES)) {
[17:28:20.206]                   name <- removed[[kk]]
[17:28:20.206]                   NAME <- NAMES[[kk]]
[17:28:20.206]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.206]                     next
[17:28:20.206]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.206]                 }
[17:28:20.206]                 if (length(args) > 0) 
[17:28:20.206]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.206]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.206]             }
[17:28:20.206]             else {
[17:28:20.206]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.206]             }
[17:28:20.206]             {
[17:28:20.206]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.206]                   0L) {
[17:28:20.206]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.206]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.206]                   base::options(opts)
[17:28:20.206]                 }
[17:28:20.206]                 {
[17:28:20.206]                   {
[17:28:20.206]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.206]                     NULL
[17:28:20.206]                   }
[17:28:20.206]                   options(future.plan = NULL)
[17:28:20.206]                   if (is.na(NA_character_)) 
[17:28:20.206]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.206]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.206]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.206]                     .init = FALSE)
[17:28:20.206]                 }
[17:28:20.206]             }
[17:28:20.206]         }
[17:28:20.206]     })
[17:28:20.206]     if (TRUE) {
[17:28:20.206]         base::sink(type = "output", split = FALSE)
[17:28:20.206]         if (TRUE) {
[17:28:20.206]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.206]         }
[17:28:20.206]         else {
[17:28:20.206]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.206]         }
[17:28:20.206]         base::close(...future.stdout)
[17:28:20.206]         ...future.stdout <- NULL
[17:28:20.206]     }
[17:28:20.206]     ...future.result$conditions <- ...future.conditions
[17:28:20.206]     ...future.result$finished <- base::Sys.time()
[17:28:20.206]     ...future.result
[17:28:20.206] }
[17:28:20.211] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.211] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.211] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.211] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.212] MultisessionFuture started
[17:28:20.212] - Launch lazy future ... done
[17:28:20.212] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-381300'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x00000266710b8668
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:28:20.227] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.227] - Validating connection of MultisessionFuture
[17:28:20.227] - received message: FutureResult
[17:28:20.228] - Received FutureResult
[17:28:20.228] - Erased future from FutureRegistry
[17:28:20.228] result() for ClusterFuture ...
[17:28:20.228] - result already collected: FutureResult
[17:28:20.228] result() for ClusterFuture ... done
[17:28:20.228] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.229] getGlobalsAndPackages() ...
[17:28:20.229] Searching for globals...
[17:28:20.230] - globals found: [3] '{', 'sample', 'x'
[17:28:20.230] Searching for globals ... DONE
[17:28:20.230] Resolving globals: FALSE
[17:28:20.231] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.231] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.231] - globals: [1] 'x'
[17:28:20.232] 
[17:28:20.232] getGlobalsAndPackages() ... DONE
[17:28:20.232] run() for 'Future' ...
[17:28:20.232] - state: 'created'
[17:28:20.232] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.246] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.246] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.246]   - Field: 'node'
[17:28:20.246]   - Field: 'label'
[17:28:20.246]   - Field: 'local'
[17:28:20.246]   - Field: 'owner'
[17:28:20.247]   - Field: 'envir'
[17:28:20.247]   - Field: 'workers'
[17:28:20.247]   - Field: 'packages'
[17:28:20.247]   - Field: 'gc'
[17:28:20.247]   - Field: 'conditions'
[17:28:20.248]   - Field: 'persistent'
[17:28:20.248]   - Field: 'expr'
[17:28:20.248]   - Field: 'uuid'
[17:28:20.248]   - Field: 'seed'
[17:28:20.248]   - Field: 'version'
[17:28:20.248]   - Field: 'result'
[17:28:20.249]   - Field: 'asynchronous'
[17:28:20.249]   - Field: 'calls'
[17:28:20.249]   - Field: 'globals'
[17:28:20.249]   - Field: 'stdout'
[17:28:20.249]   - Field: 'earlySignal'
[17:28:20.250]   - Field: 'lazy'
[17:28:20.250]   - Field: 'state'
[17:28:20.250] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.250] - Launch lazy future ...
[17:28:20.250] Packages needed by the future expression (n = 0): <none>
[17:28:20.251] Packages needed by future strategies (n = 0): <none>
[17:28:20.251] {
[17:28:20.251]     {
[17:28:20.251]         {
[17:28:20.251]             ...future.startTime <- base::Sys.time()
[17:28:20.251]             {
[17:28:20.251]                 {
[17:28:20.251]                   {
[17:28:20.251]                     {
[17:28:20.251]                       base::local({
[17:28:20.251]                         has_future <- base::requireNamespace("future", 
[17:28:20.251]                           quietly = TRUE)
[17:28:20.251]                         if (has_future) {
[17:28:20.251]                           ns <- base::getNamespace("future")
[17:28:20.251]                           version <- ns[[".package"]][["version"]]
[17:28:20.251]                           if (is.null(version)) 
[17:28:20.251]                             version <- utils::packageVersion("future")
[17:28:20.251]                         }
[17:28:20.251]                         else {
[17:28:20.251]                           version <- NULL
[17:28:20.251]                         }
[17:28:20.251]                         if (!has_future || version < "1.8.0") {
[17:28:20.251]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.251]                             "", base::R.version$version.string), 
[17:28:20.251]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.251]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.251]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.251]                               "release", "version")], collapse = " "), 
[17:28:20.251]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.251]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.251]                             info)
[17:28:20.251]                           info <- base::paste(info, collapse = "; ")
[17:28:20.251]                           if (!has_future) {
[17:28:20.251]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.251]                               info)
[17:28:20.251]                           }
[17:28:20.251]                           else {
[17:28:20.251]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.251]                               info, version)
[17:28:20.251]                           }
[17:28:20.251]                           base::stop(msg)
[17:28:20.251]                         }
[17:28:20.251]                       })
[17:28:20.251]                     }
[17:28:20.251]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.251]                     base::options(mc.cores = 1L)
[17:28:20.251]                   }
[17:28:20.251]                   ...future.strategy.old <- future::plan("list")
[17:28:20.251]                   options(future.plan = NULL)
[17:28:20.251]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.251]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.251]                 }
[17:28:20.251]                 ...future.workdir <- getwd()
[17:28:20.251]             }
[17:28:20.251]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.251]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.251]         }
[17:28:20.251]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.251]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.251]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.251]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.251]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.251]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.251]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.251]             base::names(...future.oldOptions))
[17:28:20.251]     }
[17:28:20.251]     if (FALSE) {
[17:28:20.251]     }
[17:28:20.251]     else {
[17:28:20.251]         if (TRUE) {
[17:28:20.251]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.251]                 open = "w")
[17:28:20.251]         }
[17:28:20.251]         else {
[17:28:20.251]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.251]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.251]         }
[17:28:20.251]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.251]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.251]             base::sink(type = "output", split = FALSE)
[17:28:20.251]             base::close(...future.stdout)
[17:28:20.251]         }, add = TRUE)
[17:28:20.251]     }
[17:28:20.251]     ...future.frame <- base::sys.nframe()
[17:28:20.251]     ...future.conditions <- base::list()
[17:28:20.251]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.251]     if (FALSE) {
[17:28:20.251]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.251]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.251]     }
[17:28:20.251]     ...future.result <- base::tryCatch({
[17:28:20.251]         base::withCallingHandlers({
[17:28:20.251]             ...future.value <- base::withVisible(base::local({
[17:28:20.251]                 ...future.makeSendCondition <- base::local({
[17:28:20.251]                   sendCondition <- NULL
[17:28:20.251]                   function(frame = 1L) {
[17:28:20.251]                     if (is.function(sendCondition)) 
[17:28:20.251]                       return(sendCondition)
[17:28:20.251]                     ns <- getNamespace("parallel")
[17:28:20.251]                     if (exists("sendData", mode = "function", 
[17:28:20.251]                       envir = ns)) {
[17:28:20.251]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.251]                         envir = ns)
[17:28:20.251]                       envir <- sys.frame(frame)
[17:28:20.251]                       master <- NULL
[17:28:20.251]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.251]                         !identical(envir, emptyenv())) {
[17:28:20.251]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.251]                           inherits = FALSE)) {
[17:28:20.251]                           master <- get("master", mode = "list", 
[17:28:20.251]                             envir = envir, inherits = FALSE)
[17:28:20.251]                           if (inherits(master, c("SOCKnode", 
[17:28:20.251]                             "SOCK0node"))) {
[17:28:20.251]                             sendCondition <<- function(cond) {
[17:28:20.251]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.251]                                 success = TRUE)
[17:28:20.251]                               parallel_sendData(master, data)
[17:28:20.251]                             }
[17:28:20.251]                             return(sendCondition)
[17:28:20.251]                           }
[17:28:20.251]                         }
[17:28:20.251]                         frame <- frame + 1L
[17:28:20.251]                         envir <- sys.frame(frame)
[17:28:20.251]                       }
[17:28:20.251]                     }
[17:28:20.251]                     sendCondition <<- function(cond) NULL
[17:28:20.251]                   }
[17:28:20.251]                 })
[17:28:20.251]                 withCallingHandlers({
[17:28:20.251]                   {
[17:28:20.251]                     sample(x, size = 1L)
[17:28:20.251]                   }
[17:28:20.251]                 }, immediateCondition = function(cond) {
[17:28:20.251]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.251]                   sendCondition(cond)
[17:28:20.251]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.251]                   {
[17:28:20.251]                     inherits <- base::inherits
[17:28:20.251]                     invokeRestart <- base::invokeRestart
[17:28:20.251]                     is.null <- base::is.null
[17:28:20.251]                     muffled <- FALSE
[17:28:20.251]                     if (inherits(cond, "message")) {
[17:28:20.251]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.251]                       if (muffled) 
[17:28:20.251]                         invokeRestart("muffleMessage")
[17:28:20.251]                     }
[17:28:20.251]                     else if (inherits(cond, "warning")) {
[17:28:20.251]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.251]                       if (muffled) 
[17:28:20.251]                         invokeRestart("muffleWarning")
[17:28:20.251]                     }
[17:28:20.251]                     else if (inherits(cond, "condition")) {
[17:28:20.251]                       if (!is.null(pattern)) {
[17:28:20.251]                         computeRestarts <- base::computeRestarts
[17:28:20.251]                         grepl <- base::grepl
[17:28:20.251]                         restarts <- computeRestarts(cond)
[17:28:20.251]                         for (restart in restarts) {
[17:28:20.251]                           name <- restart$name
[17:28:20.251]                           if (is.null(name)) 
[17:28:20.251]                             next
[17:28:20.251]                           if (!grepl(pattern, name)) 
[17:28:20.251]                             next
[17:28:20.251]                           invokeRestart(restart)
[17:28:20.251]                           muffled <- TRUE
[17:28:20.251]                           break
[17:28:20.251]                         }
[17:28:20.251]                       }
[17:28:20.251]                     }
[17:28:20.251]                     invisible(muffled)
[17:28:20.251]                   }
[17:28:20.251]                   muffleCondition(cond)
[17:28:20.251]                 })
[17:28:20.251]             }))
[17:28:20.251]             future::FutureResult(value = ...future.value$value, 
[17:28:20.251]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.251]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.251]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.251]                     ...future.globalenv.names))
[17:28:20.251]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.251]         }, condition = base::local({
[17:28:20.251]             c <- base::c
[17:28:20.251]             inherits <- base::inherits
[17:28:20.251]             invokeRestart <- base::invokeRestart
[17:28:20.251]             length <- base::length
[17:28:20.251]             list <- base::list
[17:28:20.251]             seq.int <- base::seq.int
[17:28:20.251]             signalCondition <- base::signalCondition
[17:28:20.251]             sys.calls <- base::sys.calls
[17:28:20.251]             `[[` <- base::`[[`
[17:28:20.251]             `+` <- base::`+`
[17:28:20.251]             `<<-` <- base::`<<-`
[17:28:20.251]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.251]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.251]                   3L)]
[17:28:20.251]             }
[17:28:20.251]             function(cond) {
[17:28:20.251]                 is_error <- inherits(cond, "error")
[17:28:20.251]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.251]                   NULL)
[17:28:20.251]                 if (is_error) {
[17:28:20.251]                   sessionInformation <- function() {
[17:28:20.251]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.251]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.251]                       search = base::search(), system = base::Sys.info())
[17:28:20.251]                   }
[17:28:20.251]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.251]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.251]                     cond$call), session = sessionInformation(), 
[17:28:20.251]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.251]                   signalCondition(cond)
[17:28:20.251]                 }
[17:28:20.251]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.251]                 "immediateCondition"))) {
[17:28:20.251]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.251]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.251]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.251]                   if (TRUE && !signal) {
[17:28:20.251]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.251]                     {
[17:28:20.251]                       inherits <- base::inherits
[17:28:20.251]                       invokeRestart <- base::invokeRestart
[17:28:20.251]                       is.null <- base::is.null
[17:28:20.251]                       muffled <- FALSE
[17:28:20.251]                       if (inherits(cond, "message")) {
[17:28:20.251]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.251]                         if (muffled) 
[17:28:20.251]                           invokeRestart("muffleMessage")
[17:28:20.251]                       }
[17:28:20.251]                       else if (inherits(cond, "warning")) {
[17:28:20.251]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.251]                         if (muffled) 
[17:28:20.251]                           invokeRestart("muffleWarning")
[17:28:20.251]                       }
[17:28:20.251]                       else if (inherits(cond, "condition")) {
[17:28:20.251]                         if (!is.null(pattern)) {
[17:28:20.251]                           computeRestarts <- base::computeRestarts
[17:28:20.251]                           grepl <- base::grepl
[17:28:20.251]                           restarts <- computeRestarts(cond)
[17:28:20.251]                           for (restart in restarts) {
[17:28:20.251]                             name <- restart$name
[17:28:20.251]                             if (is.null(name)) 
[17:28:20.251]                               next
[17:28:20.251]                             if (!grepl(pattern, name)) 
[17:28:20.251]                               next
[17:28:20.251]                             invokeRestart(restart)
[17:28:20.251]                             muffled <- TRUE
[17:28:20.251]                             break
[17:28:20.251]                           }
[17:28:20.251]                         }
[17:28:20.251]                       }
[17:28:20.251]                       invisible(muffled)
[17:28:20.251]                     }
[17:28:20.251]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.251]                   }
[17:28:20.251]                 }
[17:28:20.251]                 else {
[17:28:20.251]                   if (TRUE) {
[17:28:20.251]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.251]                     {
[17:28:20.251]                       inherits <- base::inherits
[17:28:20.251]                       invokeRestart <- base::invokeRestart
[17:28:20.251]                       is.null <- base::is.null
[17:28:20.251]                       muffled <- FALSE
[17:28:20.251]                       if (inherits(cond, "message")) {
[17:28:20.251]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.251]                         if (muffled) 
[17:28:20.251]                           invokeRestart("muffleMessage")
[17:28:20.251]                       }
[17:28:20.251]                       else if (inherits(cond, "warning")) {
[17:28:20.251]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.251]                         if (muffled) 
[17:28:20.251]                           invokeRestart("muffleWarning")
[17:28:20.251]                       }
[17:28:20.251]                       else if (inherits(cond, "condition")) {
[17:28:20.251]                         if (!is.null(pattern)) {
[17:28:20.251]                           computeRestarts <- base::computeRestarts
[17:28:20.251]                           grepl <- base::grepl
[17:28:20.251]                           restarts <- computeRestarts(cond)
[17:28:20.251]                           for (restart in restarts) {
[17:28:20.251]                             name <- restart$name
[17:28:20.251]                             if (is.null(name)) 
[17:28:20.251]                               next
[17:28:20.251]                             if (!grepl(pattern, name)) 
[17:28:20.251]                               next
[17:28:20.251]                             invokeRestart(restart)
[17:28:20.251]                             muffled <- TRUE
[17:28:20.251]                             break
[17:28:20.251]                           }
[17:28:20.251]                         }
[17:28:20.251]                       }
[17:28:20.251]                       invisible(muffled)
[17:28:20.251]                     }
[17:28:20.251]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.251]                   }
[17:28:20.251]                 }
[17:28:20.251]             }
[17:28:20.251]         }))
[17:28:20.251]     }, error = function(ex) {
[17:28:20.251]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.251]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.251]                 ...future.rng), started = ...future.startTime, 
[17:28:20.251]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.251]             version = "1.8"), class = "FutureResult")
[17:28:20.251]     }, finally = {
[17:28:20.251]         if (!identical(...future.workdir, getwd())) 
[17:28:20.251]             setwd(...future.workdir)
[17:28:20.251]         {
[17:28:20.251]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.251]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.251]             }
[17:28:20.251]             base::options(...future.oldOptions)
[17:28:20.251]             if (.Platform$OS.type == "windows") {
[17:28:20.251]                 old_names <- names(...future.oldEnvVars)
[17:28:20.251]                 envs <- base::Sys.getenv()
[17:28:20.251]                 names <- names(envs)
[17:28:20.251]                 common <- intersect(names, old_names)
[17:28:20.251]                 added <- setdiff(names, old_names)
[17:28:20.251]                 removed <- setdiff(old_names, names)
[17:28:20.251]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.251]                   envs[common]]
[17:28:20.251]                 NAMES <- toupper(changed)
[17:28:20.251]                 args <- list()
[17:28:20.251]                 for (kk in seq_along(NAMES)) {
[17:28:20.251]                   name <- changed[[kk]]
[17:28:20.251]                   NAME <- NAMES[[kk]]
[17:28:20.251]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.251]                     next
[17:28:20.251]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.251]                 }
[17:28:20.251]                 NAMES <- toupper(added)
[17:28:20.251]                 for (kk in seq_along(NAMES)) {
[17:28:20.251]                   name <- added[[kk]]
[17:28:20.251]                   NAME <- NAMES[[kk]]
[17:28:20.251]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.251]                     next
[17:28:20.251]                   args[[name]] <- ""
[17:28:20.251]                 }
[17:28:20.251]                 NAMES <- toupper(removed)
[17:28:20.251]                 for (kk in seq_along(NAMES)) {
[17:28:20.251]                   name <- removed[[kk]]
[17:28:20.251]                   NAME <- NAMES[[kk]]
[17:28:20.251]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.251]                     next
[17:28:20.251]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.251]                 }
[17:28:20.251]                 if (length(args) > 0) 
[17:28:20.251]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.251]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.251]             }
[17:28:20.251]             else {
[17:28:20.251]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.251]             }
[17:28:20.251]             {
[17:28:20.251]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.251]                   0L) {
[17:28:20.251]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.251]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.251]                   base::options(opts)
[17:28:20.251]                 }
[17:28:20.251]                 {
[17:28:20.251]                   {
[17:28:20.251]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.251]                     NULL
[17:28:20.251]                   }
[17:28:20.251]                   options(future.plan = NULL)
[17:28:20.251]                   if (is.na(NA_character_)) 
[17:28:20.251]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.251]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.251]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.251]                     .init = FALSE)
[17:28:20.251]                 }
[17:28:20.251]             }
[17:28:20.251]         }
[17:28:20.251]     })
[17:28:20.251]     if (TRUE) {
[17:28:20.251]         base::sink(type = "output", split = FALSE)
[17:28:20.251]         if (TRUE) {
[17:28:20.251]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.251]         }
[17:28:20.251]         else {
[17:28:20.251]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.251]         }
[17:28:20.251]         base::close(...future.stdout)
[17:28:20.251]         ...future.stdout <- NULL
[17:28:20.251]     }
[17:28:20.251]     ...future.result$conditions <- ...future.conditions
[17:28:20.251]     ...future.result$finished <- base::Sys.time()
[17:28:20.251]     ...future.result
[17:28:20.251] }
[17:28:20.256] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.256] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.257] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.257] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.258] MultisessionFuture started
[17:28:20.258] - Launch lazy future ... done
[17:28:20.258] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-144238'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x00000266710b8668
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:28:20.272] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.272] - Validating connection of MultisessionFuture
[17:28:20.273] - received message: FutureResult
[17:28:20.273] - Received FutureResult
[17:28:20.273] - Erased future from FutureRegistry
[17:28:20.273] result() for ClusterFuture ...
[17:28:20.273] - result already collected: FutureResult
[17:28:20.273] result() for ClusterFuture ... done
[17:28:20.274] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.274] resolve() on list ...
[17:28:20.274]  recursive: 0
[17:28:20.274]  length: 4
[17:28:20.274] 
[17:28:20.275] Future #1
[17:28:20.275] result() for ClusterFuture ...
[17:28:20.275] - result already collected: FutureResult
[17:28:20.275] result() for ClusterFuture ... done
[17:28:20.275] result() for ClusterFuture ...
[17:28:20.275] - result already collected: FutureResult
[17:28:20.275] result() for ClusterFuture ... done
[17:28:20.276] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:28:20.276] - nx: 4
[17:28:20.276] - relay: TRUE
[17:28:20.276] - stdout: TRUE
[17:28:20.276] - signal: TRUE
[17:28:20.276] - resignal: FALSE
[17:28:20.277] - force: TRUE
[17:28:20.279] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:20.279] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:20.279]  - until=1
[17:28:20.279]  - relaying element #1
[17:28:20.279] result() for ClusterFuture ...
[17:28:20.279] - result already collected: FutureResult
[17:28:20.280] result() for ClusterFuture ... done
[17:28:20.280] result() for ClusterFuture ...
[17:28:20.280] - result already collected: FutureResult
[17:28:20.280] result() for ClusterFuture ... done
[17:28:20.280] result() for ClusterFuture ...
[17:28:20.280] - result already collected: FutureResult
[17:28:20.281] result() for ClusterFuture ... done
[17:28:20.281] result() for ClusterFuture ...
[17:28:20.281] - result already collected: FutureResult
[17:28:20.281] result() for ClusterFuture ... done
[17:28:20.281] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:20.281] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:20.281] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[17:28:20.282]  length: 3 (resolved future 1)
[17:28:20.282] Future #2
[17:28:20.282] result() for ClusterFuture ...
[17:28:20.282] - result already collected: FutureResult
[17:28:20.282] result() for ClusterFuture ... done
[17:28:20.282] result() for ClusterFuture ...
[17:28:20.283] - result already collected: FutureResult
[17:28:20.283] result() for ClusterFuture ... done
[17:28:20.283] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:28:20.283] - nx: 4
[17:28:20.283] - relay: TRUE
[17:28:20.283] - stdout: TRUE
[17:28:20.283] - signal: TRUE
[17:28:20.284] - resignal: FALSE
[17:28:20.284] - force: TRUE
[17:28:20.284] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:20.284] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:20.284]  - until=2
[17:28:20.284]  - relaying element #2
[17:28:20.285] result() for ClusterFuture ...
[17:28:20.285] - result already collected: FutureResult
[17:28:20.285] result() for ClusterFuture ... done
[17:28:20.285] result() for ClusterFuture ...
[17:28:20.285] - result already collected: FutureResult
[17:28:20.285] result() for ClusterFuture ... done
[17:28:20.286] result() for ClusterFuture ...
[17:28:20.286] - result already collected: FutureResult
[17:28:20.286] result() for ClusterFuture ... done
[17:28:20.286] result() for ClusterFuture ...
[17:28:20.286] - result already collected: FutureResult
[17:28:20.286] result() for ClusterFuture ... done
[17:28:20.286] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:20.287] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:20.287] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:28:20.287]  length: 2 (resolved future 2)
[17:28:20.287] Future #3
[17:28:20.287] result() for ClusterFuture ...
[17:28:20.287] - result already collected: FutureResult
[17:28:20.288] result() for ClusterFuture ... done
[17:28:20.288] result() for ClusterFuture ...
[17:28:20.288] - result already collected: FutureResult
[17:28:20.288] result() for ClusterFuture ... done
[17:28:20.288] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:28:20.288] - nx: 4
[17:28:20.289] - relay: TRUE
[17:28:20.289] - stdout: TRUE
[17:28:20.289] - signal: TRUE
[17:28:20.289] - resignal: FALSE
[17:28:20.289] - force: TRUE
[17:28:20.289] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:20.289] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:20.290]  - until=3
[17:28:20.290]  - relaying element #3
[17:28:20.290] result() for ClusterFuture ...
[17:28:20.290] - result already collected: FutureResult
[17:28:20.290] result() for ClusterFuture ... done
[17:28:20.290] result() for ClusterFuture ...
[17:28:20.291] - result already collected: FutureResult
[17:28:20.291] result() for ClusterFuture ... done
[17:28:20.291] result() for ClusterFuture ...
[17:28:20.291] - result already collected: FutureResult
[17:28:20.291] result() for ClusterFuture ... done
[17:28:20.291] result() for ClusterFuture ...
[17:28:20.291] - result already collected: FutureResult
[17:28:20.292] result() for ClusterFuture ... done
[17:28:20.292] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:20.292] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:20.292] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:28:20.292]  length: 1 (resolved future 3)
[17:28:20.292] Future #4
[17:28:20.293] result() for ClusterFuture ...
[17:28:20.293] - result already collected: FutureResult
[17:28:20.293] result() for ClusterFuture ... done
[17:28:20.293] result() for ClusterFuture ...
[17:28:20.293] - result already collected: FutureResult
[17:28:20.293] result() for ClusterFuture ... done
[17:28:20.294] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:28:20.294] - nx: 4
[17:28:20.294] - relay: TRUE
[17:28:20.294] - stdout: TRUE
[17:28:20.294] - signal: TRUE
[17:28:20.294] - resignal: FALSE
[17:28:20.294] - force: TRUE
[17:28:20.295] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:20.295] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:20.295]  - until=4
[17:28:20.295]  - relaying element #4
[17:28:20.295] result() for ClusterFuture ...
[17:28:20.295] - result already collected: FutureResult
[17:28:20.296] result() for ClusterFuture ... done
[17:28:20.296] result() for ClusterFuture ...
[17:28:20.296] - result already collected: FutureResult
[17:28:20.296] result() for ClusterFuture ... done
[17:28:20.296] result() for ClusterFuture ...
[17:28:20.297] - result already collected: FutureResult
[17:28:20.297] result() for ClusterFuture ... done
[17:28:20.297] result() for ClusterFuture ...
[17:28:20.297] - result already collected: FutureResult
[17:28:20.297] result() for ClusterFuture ... done
[17:28:20.297] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:20.297] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:20.298] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:28:20.298]  length: 0 (resolved future 4)
[17:28:20.298] Relaying remaining futures
[17:28:20.298] signalConditionsASAP(NULL, pos=0) ...
[17:28:20.298] - nx: 4
[17:28:20.298] - relay: TRUE
[17:28:20.299] - stdout: TRUE
[17:28:20.299] - signal: TRUE
[17:28:20.299] - resignal: FALSE
[17:28:20.299] - force: TRUE
[17:28:20.299] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:20.299] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:28:20.300] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:20.300] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:20.300] signalConditionsASAP(NULL, pos=0) ... done
[17:28:20.300] resolve() on list ... DONE
[17:28:20.300] result() for ClusterFuture ...
[17:28:20.300] - result already collected: FutureResult
[17:28:20.300] result() for ClusterFuture ... done
[17:28:20.301] result() for ClusterFuture ...
[17:28:20.301] - result already collected: FutureResult
[17:28:20.301] result() for ClusterFuture ... done
[17:28:20.301] result() for ClusterFuture ...
[17:28:20.301] - result already collected: FutureResult
[17:28:20.301] result() for ClusterFuture ... done
[17:28:20.302] result() for ClusterFuture ...
[17:28:20.302] - result already collected: FutureResult
[17:28:20.302] result() for ClusterFuture ... done
[17:28:20.302] result() for ClusterFuture ...
[17:28:20.302] - result already collected: FutureResult
[17:28:20.302] result() for ClusterFuture ... done
[17:28:20.303] result() for ClusterFuture ...
[17:28:20.303] - result already collected: FutureResult
[17:28:20.303] result() for ClusterFuture ... done
[17:28:20.303] result() for ClusterFuture ...
[17:28:20.303] - result already collected: FutureResult
[17:28:20.303] result() for ClusterFuture ... done
[17:28:20.304] result() for ClusterFuture ...
[17:28:20.304] - result already collected: FutureResult
[17:28:20.304] result() for ClusterFuture ... done
[[1]]
[1] 3

[[2]]
[1] 1

[[3]]
[1] 2

[[4]]
[1] 1

[17:28:20.304] getGlobalsAndPackages() ...
[17:28:20.304] Searching for globals...
[17:28:20.306] - globals found: [3] '{', 'sample', 'x'
[17:28:20.306] Searching for globals ... DONE
[17:28:20.306] Resolving globals: FALSE
[17:28:20.306] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.307] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.307] - globals: [1] 'x'
[17:28:20.307] 
[17:28:20.307] getGlobalsAndPackages() ... DONE
[17:28:20.308] run() for 'Future' ...
[17:28:20.308] - state: 'created'
[17:28:20.308] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.323] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.323] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.324]   - Field: 'node'
[17:28:20.324]   - Field: 'label'
[17:28:20.324]   - Field: 'local'
[17:28:20.324]   - Field: 'owner'
[17:28:20.324]   - Field: 'envir'
[17:28:20.325]   - Field: 'workers'
[17:28:20.325]   - Field: 'packages'
[17:28:20.325]   - Field: 'gc'
[17:28:20.325]   - Field: 'conditions'
[17:28:20.325]   - Field: 'persistent'
[17:28:20.325]   - Field: 'expr'
[17:28:20.326]   - Field: 'uuid'
[17:28:20.326]   - Field: 'seed'
[17:28:20.326]   - Field: 'version'
[17:28:20.326]   - Field: 'result'
[17:28:20.326]   - Field: 'asynchronous'
[17:28:20.327]   - Field: 'calls'
[17:28:20.327]   - Field: 'globals'
[17:28:20.327]   - Field: 'stdout'
[17:28:20.327]   - Field: 'earlySignal'
[17:28:20.327]   - Field: 'lazy'
[17:28:20.327]   - Field: 'state'
[17:28:20.328] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.328] - Launch lazy future ...
[17:28:20.328] Packages needed by the future expression (n = 0): <none>
[17:28:20.328] Packages needed by future strategies (n = 0): <none>
[17:28:20.329] {
[17:28:20.329]     {
[17:28:20.329]         {
[17:28:20.329]             ...future.startTime <- base::Sys.time()
[17:28:20.329]             {
[17:28:20.329]                 {
[17:28:20.329]                   {
[17:28:20.329]                     {
[17:28:20.329]                       base::local({
[17:28:20.329]                         has_future <- base::requireNamespace("future", 
[17:28:20.329]                           quietly = TRUE)
[17:28:20.329]                         if (has_future) {
[17:28:20.329]                           ns <- base::getNamespace("future")
[17:28:20.329]                           version <- ns[[".package"]][["version"]]
[17:28:20.329]                           if (is.null(version)) 
[17:28:20.329]                             version <- utils::packageVersion("future")
[17:28:20.329]                         }
[17:28:20.329]                         else {
[17:28:20.329]                           version <- NULL
[17:28:20.329]                         }
[17:28:20.329]                         if (!has_future || version < "1.8.0") {
[17:28:20.329]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.329]                             "", base::R.version$version.string), 
[17:28:20.329]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.329]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.329]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.329]                               "release", "version")], collapse = " "), 
[17:28:20.329]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.329]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.329]                             info)
[17:28:20.329]                           info <- base::paste(info, collapse = "; ")
[17:28:20.329]                           if (!has_future) {
[17:28:20.329]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.329]                               info)
[17:28:20.329]                           }
[17:28:20.329]                           else {
[17:28:20.329]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.329]                               info, version)
[17:28:20.329]                           }
[17:28:20.329]                           base::stop(msg)
[17:28:20.329]                         }
[17:28:20.329]                       })
[17:28:20.329]                     }
[17:28:20.329]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.329]                     base::options(mc.cores = 1L)
[17:28:20.329]                   }
[17:28:20.329]                   ...future.strategy.old <- future::plan("list")
[17:28:20.329]                   options(future.plan = NULL)
[17:28:20.329]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.329]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.329]                 }
[17:28:20.329]                 ...future.workdir <- getwd()
[17:28:20.329]             }
[17:28:20.329]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.329]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.329]         }
[17:28:20.329]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.329]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.329]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.329]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.329]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.329]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.329]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.329]             base::names(...future.oldOptions))
[17:28:20.329]     }
[17:28:20.329]     if (FALSE) {
[17:28:20.329]     }
[17:28:20.329]     else {
[17:28:20.329]         if (TRUE) {
[17:28:20.329]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.329]                 open = "w")
[17:28:20.329]         }
[17:28:20.329]         else {
[17:28:20.329]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.329]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.329]         }
[17:28:20.329]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.329]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.329]             base::sink(type = "output", split = FALSE)
[17:28:20.329]             base::close(...future.stdout)
[17:28:20.329]         }, add = TRUE)
[17:28:20.329]     }
[17:28:20.329]     ...future.frame <- base::sys.nframe()
[17:28:20.329]     ...future.conditions <- base::list()
[17:28:20.329]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.329]     if (FALSE) {
[17:28:20.329]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.329]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.329]     }
[17:28:20.329]     ...future.result <- base::tryCatch({
[17:28:20.329]         base::withCallingHandlers({
[17:28:20.329]             ...future.value <- base::withVisible(base::local({
[17:28:20.329]                 ...future.makeSendCondition <- base::local({
[17:28:20.329]                   sendCondition <- NULL
[17:28:20.329]                   function(frame = 1L) {
[17:28:20.329]                     if (is.function(sendCondition)) 
[17:28:20.329]                       return(sendCondition)
[17:28:20.329]                     ns <- getNamespace("parallel")
[17:28:20.329]                     if (exists("sendData", mode = "function", 
[17:28:20.329]                       envir = ns)) {
[17:28:20.329]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.329]                         envir = ns)
[17:28:20.329]                       envir <- sys.frame(frame)
[17:28:20.329]                       master <- NULL
[17:28:20.329]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.329]                         !identical(envir, emptyenv())) {
[17:28:20.329]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.329]                           inherits = FALSE)) {
[17:28:20.329]                           master <- get("master", mode = "list", 
[17:28:20.329]                             envir = envir, inherits = FALSE)
[17:28:20.329]                           if (inherits(master, c("SOCKnode", 
[17:28:20.329]                             "SOCK0node"))) {
[17:28:20.329]                             sendCondition <<- function(cond) {
[17:28:20.329]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.329]                                 success = TRUE)
[17:28:20.329]                               parallel_sendData(master, data)
[17:28:20.329]                             }
[17:28:20.329]                             return(sendCondition)
[17:28:20.329]                           }
[17:28:20.329]                         }
[17:28:20.329]                         frame <- frame + 1L
[17:28:20.329]                         envir <- sys.frame(frame)
[17:28:20.329]                       }
[17:28:20.329]                     }
[17:28:20.329]                     sendCondition <<- function(cond) NULL
[17:28:20.329]                   }
[17:28:20.329]                 })
[17:28:20.329]                 withCallingHandlers({
[17:28:20.329]                   {
[17:28:20.329]                     sample(x, size = 1L)
[17:28:20.329]                   }
[17:28:20.329]                 }, immediateCondition = function(cond) {
[17:28:20.329]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.329]                   sendCondition(cond)
[17:28:20.329]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.329]                   {
[17:28:20.329]                     inherits <- base::inherits
[17:28:20.329]                     invokeRestart <- base::invokeRestart
[17:28:20.329]                     is.null <- base::is.null
[17:28:20.329]                     muffled <- FALSE
[17:28:20.329]                     if (inherits(cond, "message")) {
[17:28:20.329]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.329]                       if (muffled) 
[17:28:20.329]                         invokeRestart("muffleMessage")
[17:28:20.329]                     }
[17:28:20.329]                     else if (inherits(cond, "warning")) {
[17:28:20.329]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.329]                       if (muffled) 
[17:28:20.329]                         invokeRestart("muffleWarning")
[17:28:20.329]                     }
[17:28:20.329]                     else if (inherits(cond, "condition")) {
[17:28:20.329]                       if (!is.null(pattern)) {
[17:28:20.329]                         computeRestarts <- base::computeRestarts
[17:28:20.329]                         grepl <- base::grepl
[17:28:20.329]                         restarts <- computeRestarts(cond)
[17:28:20.329]                         for (restart in restarts) {
[17:28:20.329]                           name <- restart$name
[17:28:20.329]                           if (is.null(name)) 
[17:28:20.329]                             next
[17:28:20.329]                           if (!grepl(pattern, name)) 
[17:28:20.329]                             next
[17:28:20.329]                           invokeRestart(restart)
[17:28:20.329]                           muffled <- TRUE
[17:28:20.329]                           break
[17:28:20.329]                         }
[17:28:20.329]                       }
[17:28:20.329]                     }
[17:28:20.329]                     invisible(muffled)
[17:28:20.329]                   }
[17:28:20.329]                   muffleCondition(cond)
[17:28:20.329]                 })
[17:28:20.329]             }))
[17:28:20.329]             future::FutureResult(value = ...future.value$value, 
[17:28:20.329]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.329]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.329]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.329]                     ...future.globalenv.names))
[17:28:20.329]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.329]         }, condition = base::local({
[17:28:20.329]             c <- base::c
[17:28:20.329]             inherits <- base::inherits
[17:28:20.329]             invokeRestart <- base::invokeRestart
[17:28:20.329]             length <- base::length
[17:28:20.329]             list <- base::list
[17:28:20.329]             seq.int <- base::seq.int
[17:28:20.329]             signalCondition <- base::signalCondition
[17:28:20.329]             sys.calls <- base::sys.calls
[17:28:20.329]             `[[` <- base::`[[`
[17:28:20.329]             `+` <- base::`+`
[17:28:20.329]             `<<-` <- base::`<<-`
[17:28:20.329]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.329]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.329]                   3L)]
[17:28:20.329]             }
[17:28:20.329]             function(cond) {
[17:28:20.329]                 is_error <- inherits(cond, "error")
[17:28:20.329]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.329]                   NULL)
[17:28:20.329]                 if (is_error) {
[17:28:20.329]                   sessionInformation <- function() {
[17:28:20.329]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.329]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.329]                       search = base::search(), system = base::Sys.info())
[17:28:20.329]                   }
[17:28:20.329]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.329]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.329]                     cond$call), session = sessionInformation(), 
[17:28:20.329]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.329]                   signalCondition(cond)
[17:28:20.329]                 }
[17:28:20.329]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.329]                 "immediateCondition"))) {
[17:28:20.329]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.329]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.329]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.329]                   if (TRUE && !signal) {
[17:28:20.329]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.329]                     {
[17:28:20.329]                       inherits <- base::inherits
[17:28:20.329]                       invokeRestart <- base::invokeRestart
[17:28:20.329]                       is.null <- base::is.null
[17:28:20.329]                       muffled <- FALSE
[17:28:20.329]                       if (inherits(cond, "message")) {
[17:28:20.329]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.329]                         if (muffled) 
[17:28:20.329]                           invokeRestart("muffleMessage")
[17:28:20.329]                       }
[17:28:20.329]                       else if (inherits(cond, "warning")) {
[17:28:20.329]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.329]                         if (muffled) 
[17:28:20.329]                           invokeRestart("muffleWarning")
[17:28:20.329]                       }
[17:28:20.329]                       else if (inherits(cond, "condition")) {
[17:28:20.329]                         if (!is.null(pattern)) {
[17:28:20.329]                           computeRestarts <- base::computeRestarts
[17:28:20.329]                           grepl <- base::grepl
[17:28:20.329]                           restarts <- computeRestarts(cond)
[17:28:20.329]                           for (restart in restarts) {
[17:28:20.329]                             name <- restart$name
[17:28:20.329]                             if (is.null(name)) 
[17:28:20.329]                               next
[17:28:20.329]                             if (!grepl(pattern, name)) 
[17:28:20.329]                               next
[17:28:20.329]                             invokeRestart(restart)
[17:28:20.329]                             muffled <- TRUE
[17:28:20.329]                             break
[17:28:20.329]                           }
[17:28:20.329]                         }
[17:28:20.329]                       }
[17:28:20.329]                       invisible(muffled)
[17:28:20.329]                     }
[17:28:20.329]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.329]                   }
[17:28:20.329]                 }
[17:28:20.329]                 else {
[17:28:20.329]                   if (TRUE) {
[17:28:20.329]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.329]                     {
[17:28:20.329]                       inherits <- base::inherits
[17:28:20.329]                       invokeRestart <- base::invokeRestart
[17:28:20.329]                       is.null <- base::is.null
[17:28:20.329]                       muffled <- FALSE
[17:28:20.329]                       if (inherits(cond, "message")) {
[17:28:20.329]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.329]                         if (muffled) 
[17:28:20.329]                           invokeRestart("muffleMessage")
[17:28:20.329]                       }
[17:28:20.329]                       else if (inherits(cond, "warning")) {
[17:28:20.329]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.329]                         if (muffled) 
[17:28:20.329]                           invokeRestart("muffleWarning")
[17:28:20.329]                       }
[17:28:20.329]                       else if (inherits(cond, "condition")) {
[17:28:20.329]                         if (!is.null(pattern)) {
[17:28:20.329]                           computeRestarts <- base::computeRestarts
[17:28:20.329]                           grepl <- base::grepl
[17:28:20.329]                           restarts <- computeRestarts(cond)
[17:28:20.329]                           for (restart in restarts) {
[17:28:20.329]                             name <- restart$name
[17:28:20.329]                             if (is.null(name)) 
[17:28:20.329]                               next
[17:28:20.329]                             if (!grepl(pattern, name)) 
[17:28:20.329]                               next
[17:28:20.329]                             invokeRestart(restart)
[17:28:20.329]                             muffled <- TRUE
[17:28:20.329]                             break
[17:28:20.329]                           }
[17:28:20.329]                         }
[17:28:20.329]                       }
[17:28:20.329]                       invisible(muffled)
[17:28:20.329]                     }
[17:28:20.329]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.329]                   }
[17:28:20.329]                 }
[17:28:20.329]             }
[17:28:20.329]         }))
[17:28:20.329]     }, error = function(ex) {
[17:28:20.329]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.329]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.329]                 ...future.rng), started = ...future.startTime, 
[17:28:20.329]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.329]             version = "1.8"), class = "FutureResult")
[17:28:20.329]     }, finally = {
[17:28:20.329]         if (!identical(...future.workdir, getwd())) 
[17:28:20.329]             setwd(...future.workdir)
[17:28:20.329]         {
[17:28:20.329]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.329]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.329]             }
[17:28:20.329]             base::options(...future.oldOptions)
[17:28:20.329]             if (.Platform$OS.type == "windows") {
[17:28:20.329]                 old_names <- names(...future.oldEnvVars)
[17:28:20.329]                 envs <- base::Sys.getenv()
[17:28:20.329]                 names <- names(envs)
[17:28:20.329]                 common <- intersect(names, old_names)
[17:28:20.329]                 added <- setdiff(names, old_names)
[17:28:20.329]                 removed <- setdiff(old_names, names)
[17:28:20.329]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.329]                   envs[common]]
[17:28:20.329]                 NAMES <- toupper(changed)
[17:28:20.329]                 args <- list()
[17:28:20.329]                 for (kk in seq_along(NAMES)) {
[17:28:20.329]                   name <- changed[[kk]]
[17:28:20.329]                   NAME <- NAMES[[kk]]
[17:28:20.329]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.329]                     next
[17:28:20.329]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.329]                 }
[17:28:20.329]                 NAMES <- toupper(added)
[17:28:20.329]                 for (kk in seq_along(NAMES)) {
[17:28:20.329]                   name <- added[[kk]]
[17:28:20.329]                   NAME <- NAMES[[kk]]
[17:28:20.329]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.329]                     next
[17:28:20.329]                   args[[name]] <- ""
[17:28:20.329]                 }
[17:28:20.329]                 NAMES <- toupper(removed)
[17:28:20.329]                 for (kk in seq_along(NAMES)) {
[17:28:20.329]                   name <- removed[[kk]]
[17:28:20.329]                   NAME <- NAMES[[kk]]
[17:28:20.329]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.329]                     next
[17:28:20.329]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.329]                 }
[17:28:20.329]                 if (length(args) > 0) 
[17:28:20.329]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.329]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.329]             }
[17:28:20.329]             else {
[17:28:20.329]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.329]             }
[17:28:20.329]             {
[17:28:20.329]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.329]                   0L) {
[17:28:20.329]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.329]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.329]                   base::options(opts)
[17:28:20.329]                 }
[17:28:20.329]                 {
[17:28:20.329]                   {
[17:28:20.329]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.329]                     NULL
[17:28:20.329]                   }
[17:28:20.329]                   options(future.plan = NULL)
[17:28:20.329]                   if (is.na(NA_character_)) 
[17:28:20.329]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.329]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.329]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.329]                     .init = FALSE)
[17:28:20.329]                 }
[17:28:20.329]             }
[17:28:20.329]         }
[17:28:20.329]     })
[17:28:20.329]     if (TRUE) {
[17:28:20.329]         base::sink(type = "output", split = FALSE)
[17:28:20.329]         if (TRUE) {
[17:28:20.329]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.329]         }
[17:28:20.329]         else {
[17:28:20.329]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.329]         }
[17:28:20.329]         base::close(...future.stdout)
[17:28:20.329]         ...future.stdout <- NULL
[17:28:20.329]     }
[17:28:20.329]     ...future.result$conditions <- ...future.conditions
[17:28:20.329]     ...future.result$finished <- base::Sys.time()
[17:28:20.329]     ...future.result
[17:28:20.329] }
[17:28:20.334] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.334] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.335] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.335] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.335] MultisessionFuture started
[17:28:20.336] - Launch lazy future ... done
[17:28:20.336] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-163723'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x0000026672827a38
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:28:20.349] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.350] - Validating connection of MultisessionFuture
[17:28:20.350] - received message: FutureResult
[17:28:20.350] - Received FutureResult
[17:28:20.350] - Erased future from FutureRegistry
[17:28:20.351] result() for ClusterFuture ...
[17:28:20.351] - result already collected: FutureResult
[17:28:20.351] result() for ClusterFuture ... done
[17:28:20.351] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.351] getGlobalsAndPackages() ...
[17:28:20.351] Searching for globals...
[17:28:20.353] - globals found: [3] '{', 'sample', 'x'
[17:28:20.353] Searching for globals ... DONE
[17:28:20.353] Resolving globals: FALSE
[17:28:20.354] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.354] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.354] - globals: [1] 'x'
[17:28:20.354] 
[17:28:20.355] getGlobalsAndPackages() ... DONE
[17:28:20.355] run() for 'Future' ...
[17:28:20.355] - state: 'created'
[17:28:20.355] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.369] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.369] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.369]   - Field: 'node'
[17:28:20.369]   - Field: 'label'
[17:28:20.370]   - Field: 'local'
[17:28:20.370]   - Field: 'owner'
[17:28:20.370]   - Field: 'envir'
[17:28:20.370]   - Field: 'workers'
[17:28:20.370]   - Field: 'packages'
[17:28:20.370]   - Field: 'gc'
[17:28:20.371]   - Field: 'conditions'
[17:28:20.371]   - Field: 'persistent'
[17:28:20.371]   - Field: 'expr'
[17:28:20.371]   - Field: 'uuid'
[17:28:20.371]   - Field: 'seed'
[17:28:20.371]   - Field: 'version'
[17:28:20.372]   - Field: 'result'
[17:28:20.372]   - Field: 'asynchronous'
[17:28:20.372]   - Field: 'calls'
[17:28:20.372]   - Field: 'globals'
[17:28:20.372]   - Field: 'stdout'
[17:28:20.372]   - Field: 'earlySignal'
[17:28:20.373]   - Field: 'lazy'
[17:28:20.373]   - Field: 'state'
[17:28:20.373] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.373] - Launch lazy future ...
[17:28:20.374] Packages needed by the future expression (n = 0): <none>
[17:28:20.374] Packages needed by future strategies (n = 0): <none>
[17:28:20.374] {
[17:28:20.374]     {
[17:28:20.374]         {
[17:28:20.374]             ...future.startTime <- base::Sys.time()
[17:28:20.374]             {
[17:28:20.374]                 {
[17:28:20.374]                   {
[17:28:20.374]                     {
[17:28:20.374]                       base::local({
[17:28:20.374]                         has_future <- base::requireNamespace("future", 
[17:28:20.374]                           quietly = TRUE)
[17:28:20.374]                         if (has_future) {
[17:28:20.374]                           ns <- base::getNamespace("future")
[17:28:20.374]                           version <- ns[[".package"]][["version"]]
[17:28:20.374]                           if (is.null(version)) 
[17:28:20.374]                             version <- utils::packageVersion("future")
[17:28:20.374]                         }
[17:28:20.374]                         else {
[17:28:20.374]                           version <- NULL
[17:28:20.374]                         }
[17:28:20.374]                         if (!has_future || version < "1.8.0") {
[17:28:20.374]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.374]                             "", base::R.version$version.string), 
[17:28:20.374]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.374]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.374]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.374]                               "release", "version")], collapse = " "), 
[17:28:20.374]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.374]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.374]                             info)
[17:28:20.374]                           info <- base::paste(info, collapse = "; ")
[17:28:20.374]                           if (!has_future) {
[17:28:20.374]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.374]                               info)
[17:28:20.374]                           }
[17:28:20.374]                           else {
[17:28:20.374]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.374]                               info, version)
[17:28:20.374]                           }
[17:28:20.374]                           base::stop(msg)
[17:28:20.374]                         }
[17:28:20.374]                       })
[17:28:20.374]                     }
[17:28:20.374]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.374]                     base::options(mc.cores = 1L)
[17:28:20.374]                   }
[17:28:20.374]                   ...future.strategy.old <- future::plan("list")
[17:28:20.374]                   options(future.plan = NULL)
[17:28:20.374]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.374]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.374]                 }
[17:28:20.374]                 ...future.workdir <- getwd()
[17:28:20.374]             }
[17:28:20.374]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.374]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.374]         }
[17:28:20.374]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.374]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.374]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.374]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.374]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.374]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.374]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.374]             base::names(...future.oldOptions))
[17:28:20.374]     }
[17:28:20.374]     if (FALSE) {
[17:28:20.374]     }
[17:28:20.374]     else {
[17:28:20.374]         if (TRUE) {
[17:28:20.374]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.374]                 open = "w")
[17:28:20.374]         }
[17:28:20.374]         else {
[17:28:20.374]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.374]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.374]         }
[17:28:20.374]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.374]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.374]             base::sink(type = "output", split = FALSE)
[17:28:20.374]             base::close(...future.stdout)
[17:28:20.374]         }, add = TRUE)
[17:28:20.374]     }
[17:28:20.374]     ...future.frame <- base::sys.nframe()
[17:28:20.374]     ...future.conditions <- base::list()
[17:28:20.374]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.374]     if (FALSE) {
[17:28:20.374]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.374]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.374]     }
[17:28:20.374]     ...future.result <- base::tryCatch({
[17:28:20.374]         base::withCallingHandlers({
[17:28:20.374]             ...future.value <- base::withVisible(base::local({
[17:28:20.374]                 ...future.makeSendCondition <- base::local({
[17:28:20.374]                   sendCondition <- NULL
[17:28:20.374]                   function(frame = 1L) {
[17:28:20.374]                     if (is.function(sendCondition)) 
[17:28:20.374]                       return(sendCondition)
[17:28:20.374]                     ns <- getNamespace("parallel")
[17:28:20.374]                     if (exists("sendData", mode = "function", 
[17:28:20.374]                       envir = ns)) {
[17:28:20.374]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.374]                         envir = ns)
[17:28:20.374]                       envir <- sys.frame(frame)
[17:28:20.374]                       master <- NULL
[17:28:20.374]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.374]                         !identical(envir, emptyenv())) {
[17:28:20.374]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.374]                           inherits = FALSE)) {
[17:28:20.374]                           master <- get("master", mode = "list", 
[17:28:20.374]                             envir = envir, inherits = FALSE)
[17:28:20.374]                           if (inherits(master, c("SOCKnode", 
[17:28:20.374]                             "SOCK0node"))) {
[17:28:20.374]                             sendCondition <<- function(cond) {
[17:28:20.374]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.374]                                 success = TRUE)
[17:28:20.374]                               parallel_sendData(master, data)
[17:28:20.374]                             }
[17:28:20.374]                             return(sendCondition)
[17:28:20.374]                           }
[17:28:20.374]                         }
[17:28:20.374]                         frame <- frame + 1L
[17:28:20.374]                         envir <- sys.frame(frame)
[17:28:20.374]                       }
[17:28:20.374]                     }
[17:28:20.374]                     sendCondition <<- function(cond) NULL
[17:28:20.374]                   }
[17:28:20.374]                 })
[17:28:20.374]                 withCallingHandlers({
[17:28:20.374]                   {
[17:28:20.374]                     sample(x, size = 1L)
[17:28:20.374]                   }
[17:28:20.374]                 }, immediateCondition = function(cond) {
[17:28:20.374]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.374]                   sendCondition(cond)
[17:28:20.374]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.374]                   {
[17:28:20.374]                     inherits <- base::inherits
[17:28:20.374]                     invokeRestart <- base::invokeRestart
[17:28:20.374]                     is.null <- base::is.null
[17:28:20.374]                     muffled <- FALSE
[17:28:20.374]                     if (inherits(cond, "message")) {
[17:28:20.374]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.374]                       if (muffled) 
[17:28:20.374]                         invokeRestart("muffleMessage")
[17:28:20.374]                     }
[17:28:20.374]                     else if (inherits(cond, "warning")) {
[17:28:20.374]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.374]                       if (muffled) 
[17:28:20.374]                         invokeRestart("muffleWarning")
[17:28:20.374]                     }
[17:28:20.374]                     else if (inherits(cond, "condition")) {
[17:28:20.374]                       if (!is.null(pattern)) {
[17:28:20.374]                         computeRestarts <- base::computeRestarts
[17:28:20.374]                         grepl <- base::grepl
[17:28:20.374]                         restarts <- computeRestarts(cond)
[17:28:20.374]                         for (restart in restarts) {
[17:28:20.374]                           name <- restart$name
[17:28:20.374]                           if (is.null(name)) 
[17:28:20.374]                             next
[17:28:20.374]                           if (!grepl(pattern, name)) 
[17:28:20.374]                             next
[17:28:20.374]                           invokeRestart(restart)
[17:28:20.374]                           muffled <- TRUE
[17:28:20.374]                           break
[17:28:20.374]                         }
[17:28:20.374]                       }
[17:28:20.374]                     }
[17:28:20.374]                     invisible(muffled)
[17:28:20.374]                   }
[17:28:20.374]                   muffleCondition(cond)
[17:28:20.374]                 })
[17:28:20.374]             }))
[17:28:20.374]             future::FutureResult(value = ...future.value$value, 
[17:28:20.374]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.374]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.374]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.374]                     ...future.globalenv.names))
[17:28:20.374]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.374]         }, condition = base::local({
[17:28:20.374]             c <- base::c
[17:28:20.374]             inherits <- base::inherits
[17:28:20.374]             invokeRestart <- base::invokeRestart
[17:28:20.374]             length <- base::length
[17:28:20.374]             list <- base::list
[17:28:20.374]             seq.int <- base::seq.int
[17:28:20.374]             signalCondition <- base::signalCondition
[17:28:20.374]             sys.calls <- base::sys.calls
[17:28:20.374]             `[[` <- base::`[[`
[17:28:20.374]             `+` <- base::`+`
[17:28:20.374]             `<<-` <- base::`<<-`
[17:28:20.374]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.374]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.374]                   3L)]
[17:28:20.374]             }
[17:28:20.374]             function(cond) {
[17:28:20.374]                 is_error <- inherits(cond, "error")
[17:28:20.374]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.374]                   NULL)
[17:28:20.374]                 if (is_error) {
[17:28:20.374]                   sessionInformation <- function() {
[17:28:20.374]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.374]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.374]                       search = base::search(), system = base::Sys.info())
[17:28:20.374]                   }
[17:28:20.374]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.374]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.374]                     cond$call), session = sessionInformation(), 
[17:28:20.374]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.374]                   signalCondition(cond)
[17:28:20.374]                 }
[17:28:20.374]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.374]                 "immediateCondition"))) {
[17:28:20.374]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.374]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.374]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.374]                   if (TRUE && !signal) {
[17:28:20.374]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.374]                     {
[17:28:20.374]                       inherits <- base::inherits
[17:28:20.374]                       invokeRestart <- base::invokeRestart
[17:28:20.374]                       is.null <- base::is.null
[17:28:20.374]                       muffled <- FALSE
[17:28:20.374]                       if (inherits(cond, "message")) {
[17:28:20.374]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.374]                         if (muffled) 
[17:28:20.374]                           invokeRestart("muffleMessage")
[17:28:20.374]                       }
[17:28:20.374]                       else if (inherits(cond, "warning")) {
[17:28:20.374]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.374]                         if (muffled) 
[17:28:20.374]                           invokeRestart("muffleWarning")
[17:28:20.374]                       }
[17:28:20.374]                       else if (inherits(cond, "condition")) {
[17:28:20.374]                         if (!is.null(pattern)) {
[17:28:20.374]                           computeRestarts <- base::computeRestarts
[17:28:20.374]                           grepl <- base::grepl
[17:28:20.374]                           restarts <- computeRestarts(cond)
[17:28:20.374]                           for (restart in restarts) {
[17:28:20.374]                             name <- restart$name
[17:28:20.374]                             if (is.null(name)) 
[17:28:20.374]                               next
[17:28:20.374]                             if (!grepl(pattern, name)) 
[17:28:20.374]                               next
[17:28:20.374]                             invokeRestart(restart)
[17:28:20.374]                             muffled <- TRUE
[17:28:20.374]                             break
[17:28:20.374]                           }
[17:28:20.374]                         }
[17:28:20.374]                       }
[17:28:20.374]                       invisible(muffled)
[17:28:20.374]                     }
[17:28:20.374]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.374]                   }
[17:28:20.374]                 }
[17:28:20.374]                 else {
[17:28:20.374]                   if (TRUE) {
[17:28:20.374]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.374]                     {
[17:28:20.374]                       inherits <- base::inherits
[17:28:20.374]                       invokeRestart <- base::invokeRestart
[17:28:20.374]                       is.null <- base::is.null
[17:28:20.374]                       muffled <- FALSE
[17:28:20.374]                       if (inherits(cond, "message")) {
[17:28:20.374]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.374]                         if (muffled) 
[17:28:20.374]                           invokeRestart("muffleMessage")
[17:28:20.374]                       }
[17:28:20.374]                       else if (inherits(cond, "warning")) {
[17:28:20.374]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.374]                         if (muffled) 
[17:28:20.374]                           invokeRestart("muffleWarning")
[17:28:20.374]                       }
[17:28:20.374]                       else if (inherits(cond, "condition")) {
[17:28:20.374]                         if (!is.null(pattern)) {
[17:28:20.374]                           computeRestarts <- base::computeRestarts
[17:28:20.374]                           grepl <- base::grepl
[17:28:20.374]                           restarts <- computeRestarts(cond)
[17:28:20.374]                           for (restart in restarts) {
[17:28:20.374]                             name <- restart$name
[17:28:20.374]                             if (is.null(name)) 
[17:28:20.374]                               next
[17:28:20.374]                             if (!grepl(pattern, name)) 
[17:28:20.374]                               next
[17:28:20.374]                             invokeRestart(restart)
[17:28:20.374]                             muffled <- TRUE
[17:28:20.374]                             break
[17:28:20.374]                           }
[17:28:20.374]                         }
[17:28:20.374]                       }
[17:28:20.374]                       invisible(muffled)
[17:28:20.374]                     }
[17:28:20.374]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.374]                   }
[17:28:20.374]                 }
[17:28:20.374]             }
[17:28:20.374]         }))
[17:28:20.374]     }, error = function(ex) {
[17:28:20.374]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.374]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.374]                 ...future.rng), started = ...future.startTime, 
[17:28:20.374]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.374]             version = "1.8"), class = "FutureResult")
[17:28:20.374]     }, finally = {
[17:28:20.374]         if (!identical(...future.workdir, getwd())) 
[17:28:20.374]             setwd(...future.workdir)
[17:28:20.374]         {
[17:28:20.374]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.374]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.374]             }
[17:28:20.374]             base::options(...future.oldOptions)
[17:28:20.374]             if (.Platform$OS.type == "windows") {
[17:28:20.374]                 old_names <- names(...future.oldEnvVars)
[17:28:20.374]                 envs <- base::Sys.getenv()
[17:28:20.374]                 names <- names(envs)
[17:28:20.374]                 common <- intersect(names, old_names)
[17:28:20.374]                 added <- setdiff(names, old_names)
[17:28:20.374]                 removed <- setdiff(old_names, names)
[17:28:20.374]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.374]                   envs[common]]
[17:28:20.374]                 NAMES <- toupper(changed)
[17:28:20.374]                 args <- list()
[17:28:20.374]                 for (kk in seq_along(NAMES)) {
[17:28:20.374]                   name <- changed[[kk]]
[17:28:20.374]                   NAME <- NAMES[[kk]]
[17:28:20.374]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.374]                     next
[17:28:20.374]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.374]                 }
[17:28:20.374]                 NAMES <- toupper(added)
[17:28:20.374]                 for (kk in seq_along(NAMES)) {
[17:28:20.374]                   name <- added[[kk]]
[17:28:20.374]                   NAME <- NAMES[[kk]]
[17:28:20.374]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.374]                     next
[17:28:20.374]                   args[[name]] <- ""
[17:28:20.374]                 }
[17:28:20.374]                 NAMES <- toupper(removed)
[17:28:20.374]                 for (kk in seq_along(NAMES)) {
[17:28:20.374]                   name <- removed[[kk]]
[17:28:20.374]                   NAME <- NAMES[[kk]]
[17:28:20.374]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.374]                     next
[17:28:20.374]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.374]                 }
[17:28:20.374]                 if (length(args) > 0) 
[17:28:20.374]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.374]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.374]             }
[17:28:20.374]             else {
[17:28:20.374]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.374]             }
[17:28:20.374]             {
[17:28:20.374]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.374]                   0L) {
[17:28:20.374]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.374]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.374]                   base::options(opts)
[17:28:20.374]                 }
[17:28:20.374]                 {
[17:28:20.374]                   {
[17:28:20.374]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.374]                     NULL
[17:28:20.374]                   }
[17:28:20.374]                   options(future.plan = NULL)
[17:28:20.374]                   if (is.na(NA_character_)) 
[17:28:20.374]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.374]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.374]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.374]                     .init = FALSE)
[17:28:20.374]                 }
[17:28:20.374]             }
[17:28:20.374]         }
[17:28:20.374]     })
[17:28:20.374]     if (TRUE) {
[17:28:20.374]         base::sink(type = "output", split = FALSE)
[17:28:20.374]         if (TRUE) {
[17:28:20.374]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.374]         }
[17:28:20.374]         else {
[17:28:20.374]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.374]         }
[17:28:20.374]         base::close(...future.stdout)
[17:28:20.374]         ...future.stdout <- NULL
[17:28:20.374]     }
[17:28:20.374]     ...future.result$conditions <- ...future.conditions
[17:28:20.374]     ...future.result$finished <- base::Sys.time()
[17:28:20.374]     ...future.result
[17:28:20.374] }
[17:28:20.379] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.379] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.380] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.380] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.381] MultisessionFuture started
[17:28:20.381] - Launch lazy future ... done
[17:28:20.381] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-919933'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x0000026672827a38
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:28:20.395] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.396] - Validating connection of MultisessionFuture
[17:28:20.396] - received message: FutureResult
[17:28:20.396] - Received FutureResult
[17:28:20.396] - Erased future from FutureRegistry
[17:28:20.396] result() for ClusterFuture ...
[17:28:20.397] - result already collected: FutureResult
[17:28:20.397] result() for ClusterFuture ... done
[17:28:20.397] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.397] getGlobalsAndPackages() ...
[17:28:20.397] Searching for globals...
[17:28:20.398] - globals found: [3] '{', 'sample', 'x'
[17:28:20.399] Searching for globals ... DONE
[17:28:20.399] Resolving globals: FALSE
[17:28:20.399] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.400] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.400] - globals: [1] 'x'
[17:28:20.400] 
[17:28:20.400] getGlobalsAndPackages() ... DONE
[17:28:20.401] run() for 'Future' ...
[17:28:20.401] - state: 'created'
[17:28:20.401] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.414] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.414] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.415]   - Field: 'node'
[17:28:20.415]   - Field: 'label'
[17:28:20.415]   - Field: 'local'
[17:28:20.415]   - Field: 'owner'
[17:28:20.415]   - Field: 'envir'
[17:28:20.416]   - Field: 'workers'
[17:28:20.416]   - Field: 'packages'
[17:28:20.416]   - Field: 'gc'
[17:28:20.416]   - Field: 'conditions'
[17:28:20.416]   - Field: 'persistent'
[17:28:20.416]   - Field: 'expr'
[17:28:20.417]   - Field: 'uuid'
[17:28:20.417]   - Field: 'seed'
[17:28:20.417]   - Field: 'version'
[17:28:20.417]   - Field: 'result'
[17:28:20.417]   - Field: 'asynchronous'
[17:28:20.417]   - Field: 'calls'
[17:28:20.418]   - Field: 'globals'
[17:28:20.418]   - Field: 'stdout'
[17:28:20.418]   - Field: 'earlySignal'
[17:28:20.418]   - Field: 'lazy'
[17:28:20.418]   - Field: 'state'
[17:28:20.419] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.419] - Launch lazy future ...
[17:28:20.419] Packages needed by the future expression (n = 0): <none>
[17:28:20.419] Packages needed by future strategies (n = 0): <none>
[17:28:20.420] {
[17:28:20.420]     {
[17:28:20.420]         {
[17:28:20.420]             ...future.startTime <- base::Sys.time()
[17:28:20.420]             {
[17:28:20.420]                 {
[17:28:20.420]                   {
[17:28:20.420]                     {
[17:28:20.420]                       base::local({
[17:28:20.420]                         has_future <- base::requireNamespace("future", 
[17:28:20.420]                           quietly = TRUE)
[17:28:20.420]                         if (has_future) {
[17:28:20.420]                           ns <- base::getNamespace("future")
[17:28:20.420]                           version <- ns[[".package"]][["version"]]
[17:28:20.420]                           if (is.null(version)) 
[17:28:20.420]                             version <- utils::packageVersion("future")
[17:28:20.420]                         }
[17:28:20.420]                         else {
[17:28:20.420]                           version <- NULL
[17:28:20.420]                         }
[17:28:20.420]                         if (!has_future || version < "1.8.0") {
[17:28:20.420]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.420]                             "", base::R.version$version.string), 
[17:28:20.420]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.420]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.420]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.420]                               "release", "version")], collapse = " "), 
[17:28:20.420]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.420]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.420]                             info)
[17:28:20.420]                           info <- base::paste(info, collapse = "; ")
[17:28:20.420]                           if (!has_future) {
[17:28:20.420]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.420]                               info)
[17:28:20.420]                           }
[17:28:20.420]                           else {
[17:28:20.420]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.420]                               info, version)
[17:28:20.420]                           }
[17:28:20.420]                           base::stop(msg)
[17:28:20.420]                         }
[17:28:20.420]                       })
[17:28:20.420]                     }
[17:28:20.420]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.420]                     base::options(mc.cores = 1L)
[17:28:20.420]                   }
[17:28:20.420]                   ...future.strategy.old <- future::plan("list")
[17:28:20.420]                   options(future.plan = NULL)
[17:28:20.420]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.420]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.420]                 }
[17:28:20.420]                 ...future.workdir <- getwd()
[17:28:20.420]             }
[17:28:20.420]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.420]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.420]         }
[17:28:20.420]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.420]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.420]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.420]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.420]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.420]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.420]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.420]             base::names(...future.oldOptions))
[17:28:20.420]     }
[17:28:20.420]     if (FALSE) {
[17:28:20.420]     }
[17:28:20.420]     else {
[17:28:20.420]         if (TRUE) {
[17:28:20.420]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.420]                 open = "w")
[17:28:20.420]         }
[17:28:20.420]         else {
[17:28:20.420]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.420]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.420]         }
[17:28:20.420]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.420]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.420]             base::sink(type = "output", split = FALSE)
[17:28:20.420]             base::close(...future.stdout)
[17:28:20.420]         }, add = TRUE)
[17:28:20.420]     }
[17:28:20.420]     ...future.frame <- base::sys.nframe()
[17:28:20.420]     ...future.conditions <- base::list()
[17:28:20.420]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.420]     if (FALSE) {
[17:28:20.420]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.420]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.420]     }
[17:28:20.420]     ...future.result <- base::tryCatch({
[17:28:20.420]         base::withCallingHandlers({
[17:28:20.420]             ...future.value <- base::withVisible(base::local({
[17:28:20.420]                 ...future.makeSendCondition <- base::local({
[17:28:20.420]                   sendCondition <- NULL
[17:28:20.420]                   function(frame = 1L) {
[17:28:20.420]                     if (is.function(sendCondition)) 
[17:28:20.420]                       return(sendCondition)
[17:28:20.420]                     ns <- getNamespace("parallel")
[17:28:20.420]                     if (exists("sendData", mode = "function", 
[17:28:20.420]                       envir = ns)) {
[17:28:20.420]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.420]                         envir = ns)
[17:28:20.420]                       envir <- sys.frame(frame)
[17:28:20.420]                       master <- NULL
[17:28:20.420]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.420]                         !identical(envir, emptyenv())) {
[17:28:20.420]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.420]                           inherits = FALSE)) {
[17:28:20.420]                           master <- get("master", mode = "list", 
[17:28:20.420]                             envir = envir, inherits = FALSE)
[17:28:20.420]                           if (inherits(master, c("SOCKnode", 
[17:28:20.420]                             "SOCK0node"))) {
[17:28:20.420]                             sendCondition <<- function(cond) {
[17:28:20.420]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.420]                                 success = TRUE)
[17:28:20.420]                               parallel_sendData(master, data)
[17:28:20.420]                             }
[17:28:20.420]                             return(sendCondition)
[17:28:20.420]                           }
[17:28:20.420]                         }
[17:28:20.420]                         frame <- frame + 1L
[17:28:20.420]                         envir <- sys.frame(frame)
[17:28:20.420]                       }
[17:28:20.420]                     }
[17:28:20.420]                     sendCondition <<- function(cond) NULL
[17:28:20.420]                   }
[17:28:20.420]                 })
[17:28:20.420]                 withCallingHandlers({
[17:28:20.420]                   {
[17:28:20.420]                     sample(x, size = 1L)
[17:28:20.420]                   }
[17:28:20.420]                 }, immediateCondition = function(cond) {
[17:28:20.420]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.420]                   sendCondition(cond)
[17:28:20.420]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.420]                   {
[17:28:20.420]                     inherits <- base::inherits
[17:28:20.420]                     invokeRestart <- base::invokeRestart
[17:28:20.420]                     is.null <- base::is.null
[17:28:20.420]                     muffled <- FALSE
[17:28:20.420]                     if (inherits(cond, "message")) {
[17:28:20.420]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.420]                       if (muffled) 
[17:28:20.420]                         invokeRestart("muffleMessage")
[17:28:20.420]                     }
[17:28:20.420]                     else if (inherits(cond, "warning")) {
[17:28:20.420]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.420]                       if (muffled) 
[17:28:20.420]                         invokeRestart("muffleWarning")
[17:28:20.420]                     }
[17:28:20.420]                     else if (inherits(cond, "condition")) {
[17:28:20.420]                       if (!is.null(pattern)) {
[17:28:20.420]                         computeRestarts <- base::computeRestarts
[17:28:20.420]                         grepl <- base::grepl
[17:28:20.420]                         restarts <- computeRestarts(cond)
[17:28:20.420]                         for (restart in restarts) {
[17:28:20.420]                           name <- restart$name
[17:28:20.420]                           if (is.null(name)) 
[17:28:20.420]                             next
[17:28:20.420]                           if (!grepl(pattern, name)) 
[17:28:20.420]                             next
[17:28:20.420]                           invokeRestart(restart)
[17:28:20.420]                           muffled <- TRUE
[17:28:20.420]                           break
[17:28:20.420]                         }
[17:28:20.420]                       }
[17:28:20.420]                     }
[17:28:20.420]                     invisible(muffled)
[17:28:20.420]                   }
[17:28:20.420]                   muffleCondition(cond)
[17:28:20.420]                 })
[17:28:20.420]             }))
[17:28:20.420]             future::FutureResult(value = ...future.value$value, 
[17:28:20.420]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.420]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.420]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.420]                     ...future.globalenv.names))
[17:28:20.420]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.420]         }, condition = base::local({
[17:28:20.420]             c <- base::c
[17:28:20.420]             inherits <- base::inherits
[17:28:20.420]             invokeRestart <- base::invokeRestart
[17:28:20.420]             length <- base::length
[17:28:20.420]             list <- base::list
[17:28:20.420]             seq.int <- base::seq.int
[17:28:20.420]             signalCondition <- base::signalCondition
[17:28:20.420]             sys.calls <- base::sys.calls
[17:28:20.420]             `[[` <- base::`[[`
[17:28:20.420]             `+` <- base::`+`
[17:28:20.420]             `<<-` <- base::`<<-`
[17:28:20.420]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.420]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.420]                   3L)]
[17:28:20.420]             }
[17:28:20.420]             function(cond) {
[17:28:20.420]                 is_error <- inherits(cond, "error")
[17:28:20.420]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.420]                   NULL)
[17:28:20.420]                 if (is_error) {
[17:28:20.420]                   sessionInformation <- function() {
[17:28:20.420]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.420]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.420]                       search = base::search(), system = base::Sys.info())
[17:28:20.420]                   }
[17:28:20.420]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.420]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.420]                     cond$call), session = sessionInformation(), 
[17:28:20.420]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.420]                   signalCondition(cond)
[17:28:20.420]                 }
[17:28:20.420]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.420]                 "immediateCondition"))) {
[17:28:20.420]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.420]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.420]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.420]                   if (TRUE && !signal) {
[17:28:20.420]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.420]                     {
[17:28:20.420]                       inherits <- base::inherits
[17:28:20.420]                       invokeRestart <- base::invokeRestart
[17:28:20.420]                       is.null <- base::is.null
[17:28:20.420]                       muffled <- FALSE
[17:28:20.420]                       if (inherits(cond, "message")) {
[17:28:20.420]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.420]                         if (muffled) 
[17:28:20.420]                           invokeRestart("muffleMessage")
[17:28:20.420]                       }
[17:28:20.420]                       else if (inherits(cond, "warning")) {
[17:28:20.420]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.420]                         if (muffled) 
[17:28:20.420]                           invokeRestart("muffleWarning")
[17:28:20.420]                       }
[17:28:20.420]                       else if (inherits(cond, "condition")) {
[17:28:20.420]                         if (!is.null(pattern)) {
[17:28:20.420]                           computeRestarts <- base::computeRestarts
[17:28:20.420]                           grepl <- base::grepl
[17:28:20.420]                           restarts <- computeRestarts(cond)
[17:28:20.420]                           for (restart in restarts) {
[17:28:20.420]                             name <- restart$name
[17:28:20.420]                             if (is.null(name)) 
[17:28:20.420]                               next
[17:28:20.420]                             if (!grepl(pattern, name)) 
[17:28:20.420]                               next
[17:28:20.420]                             invokeRestart(restart)
[17:28:20.420]                             muffled <- TRUE
[17:28:20.420]                             break
[17:28:20.420]                           }
[17:28:20.420]                         }
[17:28:20.420]                       }
[17:28:20.420]                       invisible(muffled)
[17:28:20.420]                     }
[17:28:20.420]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.420]                   }
[17:28:20.420]                 }
[17:28:20.420]                 else {
[17:28:20.420]                   if (TRUE) {
[17:28:20.420]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.420]                     {
[17:28:20.420]                       inherits <- base::inherits
[17:28:20.420]                       invokeRestart <- base::invokeRestart
[17:28:20.420]                       is.null <- base::is.null
[17:28:20.420]                       muffled <- FALSE
[17:28:20.420]                       if (inherits(cond, "message")) {
[17:28:20.420]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.420]                         if (muffled) 
[17:28:20.420]                           invokeRestart("muffleMessage")
[17:28:20.420]                       }
[17:28:20.420]                       else if (inherits(cond, "warning")) {
[17:28:20.420]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.420]                         if (muffled) 
[17:28:20.420]                           invokeRestart("muffleWarning")
[17:28:20.420]                       }
[17:28:20.420]                       else if (inherits(cond, "condition")) {
[17:28:20.420]                         if (!is.null(pattern)) {
[17:28:20.420]                           computeRestarts <- base::computeRestarts
[17:28:20.420]                           grepl <- base::grepl
[17:28:20.420]                           restarts <- computeRestarts(cond)
[17:28:20.420]                           for (restart in restarts) {
[17:28:20.420]                             name <- restart$name
[17:28:20.420]                             if (is.null(name)) 
[17:28:20.420]                               next
[17:28:20.420]                             if (!grepl(pattern, name)) 
[17:28:20.420]                               next
[17:28:20.420]                             invokeRestart(restart)
[17:28:20.420]                             muffled <- TRUE
[17:28:20.420]                             break
[17:28:20.420]                           }
[17:28:20.420]                         }
[17:28:20.420]                       }
[17:28:20.420]                       invisible(muffled)
[17:28:20.420]                     }
[17:28:20.420]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.420]                   }
[17:28:20.420]                 }
[17:28:20.420]             }
[17:28:20.420]         }))
[17:28:20.420]     }, error = function(ex) {
[17:28:20.420]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.420]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.420]                 ...future.rng), started = ...future.startTime, 
[17:28:20.420]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.420]             version = "1.8"), class = "FutureResult")
[17:28:20.420]     }, finally = {
[17:28:20.420]         if (!identical(...future.workdir, getwd())) 
[17:28:20.420]             setwd(...future.workdir)
[17:28:20.420]         {
[17:28:20.420]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.420]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.420]             }
[17:28:20.420]             base::options(...future.oldOptions)
[17:28:20.420]             if (.Platform$OS.type == "windows") {
[17:28:20.420]                 old_names <- names(...future.oldEnvVars)
[17:28:20.420]                 envs <- base::Sys.getenv()
[17:28:20.420]                 names <- names(envs)
[17:28:20.420]                 common <- intersect(names, old_names)
[17:28:20.420]                 added <- setdiff(names, old_names)
[17:28:20.420]                 removed <- setdiff(old_names, names)
[17:28:20.420]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.420]                   envs[common]]
[17:28:20.420]                 NAMES <- toupper(changed)
[17:28:20.420]                 args <- list()
[17:28:20.420]                 for (kk in seq_along(NAMES)) {
[17:28:20.420]                   name <- changed[[kk]]
[17:28:20.420]                   NAME <- NAMES[[kk]]
[17:28:20.420]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.420]                     next
[17:28:20.420]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.420]                 }
[17:28:20.420]                 NAMES <- toupper(added)
[17:28:20.420]                 for (kk in seq_along(NAMES)) {
[17:28:20.420]                   name <- added[[kk]]
[17:28:20.420]                   NAME <- NAMES[[kk]]
[17:28:20.420]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.420]                     next
[17:28:20.420]                   args[[name]] <- ""
[17:28:20.420]                 }
[17:28:20.420]                 NAMES <- toupper(removed)
[17:28:20.420]                 for (kk in seq_along(NAMES)) {
[17:28:20.420]                   name <- removed[[kk]]
[17:28:20.420]                   NAME <- NAMES[[kk]]
[17:28:20.420]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.420]                     next
[17:28:20.420]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.420]                 }
[17:28:20.420]                 if (length(args) > 0) 
[17:28:20.420]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.420]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.420]             }
[17:28:20.420]             else {
[17:28:20.420]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.420]             }
[17:28:20.420]             {
[17:28:20.420]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.420]                   0L) {
[17:28:20.420]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.420]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.420]                   base::options(opts)
[17:28:20.420]                 }
[17:28:20.420]                 {
[17:28:20.420]                   {
[17:28:20.420]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.420]                     NULL
[17:28:20.420]                   }
[17:28:20.420]                   options(future.plan = NULL)
[17:28:20.420]                   if (is.na(NA_character_)) 
[17:28:20.420]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.420]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.420]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.420]                     .init = FALSE)
[17:28:20.420]                 }
[17:28:20.420]             }
[17:28:20.420]         }
[17:28:20.420]     })
[17:28:20.420]     if (TRUE) {
[17:28:20.420]         base::sink(type = "output", split = FALSE)
[17:28:20.420]         if (TRUE) {
[17:28:20.420]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.420]         }
[17:28:20.420]         else {
[17:28:20.420]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.420]         }
[17:28:20.420]         base::close(...future.stdout)
[17:28:20.420]         ...future.stdout <- NULL
[17:28:20.420]     }
[17:28:20.420]     ...future.result$conditions <- ...future.conditions
[17:28:20.420]     ...future.result$finished <- base::Sys.time()
[17:28:20.420]     ...future.result
[17:28:20.420] }
[17:28:20.425] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.425] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.425] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.426] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.426] MultisessionFuture started
[17:28:20.426] - Launch lazy future ... done
[17:28:20.427] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-894414'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x0000026672827a38
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:28:20.440] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.440] - Validating connection of MultisessionFuture
[17:28:20.440] - received message: FutureResult
[17:28:20.440] - Received FutureResult
[17:28:20.441] - Erased future from FutureRegistry
[17:28:20.441] result() for ClusterFuture ...
[17:28:20.441] - result already collected: FutureResult
[17:28:20.441] result() for ClusterFuture ... done
[17:28:20.441] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.441] getGlobalsAndPackages() ...
[17:28:20.442] Searching for globals...
[17:28:20.443] - globals found: [3] '{', 'sample', 'x'
[17:28:20.443] Searching for globals ... DONE
[17:28:20.443] Resolving globals: FALSE
[17:28:20.444] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.444] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.444] - globals: [1] 'x'
[17:28:20.444] 
[17:28:20.445] getGlobalsAndPackages() ... DONE
[17:28:20.445] run() for 'Future' ...
[17:28:20.445] - state: 'created'
[17:28:20.445] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.459] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.459] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.459]   - Field: 'node'
[17:28:20.459]   - Field: 'label'
[17:28:20.460]   - Field: 'local'
[17:28:20.460]   - Field: 'owner'
[17:28:20.460]   - Field: 'envir'
[17:28:20.460]   - Field: 'workers'
[17:28:20.460]   - Field: 'packages'
[17:28:20.460]   - Field: 'gc'
[17:28:20.461]   - Field: 'conditions'
[17:28:20.461]   - Field: 'persistent'
[17:28:20.461]   - Field: 'expr'
[17:28:20.461]   - Field: 'uuid'
[17:28:20.462]   - Field: 'seed'
[17:28:20.462]   - Field: 'version'
[17:28:20.462]   - Field: 'result'
[17:28:20.462]   - Field: 'asynchronous'
[17:28:20.462]   - Field: 'calls'
[17:28:20.462]   - Field: 'globals'
[17:28:20.463]   - Field: 'stdout'
[17:28:20.463]   - Field: 'earlySignal'
[17:28:20.463]   - Field: 'lazy'
[17:28:20.463]   - Field: 'state'
[17:28:20.463] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.463] - Launch lazy future ...
[17:28:20.464] Packages needed by the future expression (n = 0): <none>
[17:28:20.464] Packages needed by future strategies (n = 0): <none>
[17:28:20.464] {
[17:28:20.464]     {
[17:28:20.464]         {
[17:28:20.464]             ...future.startTime <- base::Sys.time()
[17:28:20.464]             {
[17:28:20.464]                 {
[17:28:20.464]                   {
[17:28:20.464]                     {
[17:28:20.464]                       base::local({
[17:28:20.464]                         has_future <- base::requireNamespace("future", 
[17:28:20.464]                           quietly = TRUE)
[17:28:20.464]                         if (has_future) {
[17:28:20.464]                           ns <- base::getNamespace("future")
[17:28:20.464]                           version <- ns[[".package"]][["version"]]
[17:28:20.464]                           if (is.null(version)) 
[17:28:20.464]                             version <- utils::packageVersion("future")
[17:28:20.464]                         }
[17:28:20.464]                         else {
[17:28:20.464]                           version <- NULL
[17:28:20.464]                         }
[17:28:20.464]                         if (!has_future || version < "1.8.0") {
[17:28:20.464]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.464]                             "", base::R.version$version.string), 
[17:28:20.464]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.464]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.464]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.464]                               "release", "version")], collapse = " "), 
[17:28:20.464]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.464]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.464]                             info)
[17:28:20.464]                           info <- base::paste(info, collapse = "; ")
[17:28:20.464]                           if (!has_future) {
[17:28:20.464]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.464]                               info)
[17:28:20.464]                           }
[17:28:20.464]                           else {
[17:28:20.464]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.464]                               info, version)
[17:28:20.464]                           }
[17:28:20.464]                           base::stop(msg)
[17:28:20.464]                         }
[17:28:20.464]                       })
[17:28:20.464]                     }
[17:28:20.464]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.464]                     base::options(mc.cores = 1L)
[17:28:20.464]                   }
[17:28:20.464]                   ...future.strategy.old <- future::plan("list")
[17:28:20.464]                   options(future.plan = NULL)
[17:28:20.464]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.464]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.464]                 }
[17:28:20.464]                 ...future.workdir <- getwd()
[17:28:20.464]             }
[17:28:20.464]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.464]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.464]         }
[17:28:20.464]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.464]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.464]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.464]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.464]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.464]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.464]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.464]             base::names(...future.oldOptions))
[17:28:20.464]     }
[17:28:20.464]     if (FALSE) {
[17:28:20.464]     }
[17:28:20.464]     else {
[17:28:20.464]         if (TRUE) {
[17:28:20.464]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.464]                 open = "w")
[17:28:20.464]         }
[17:28:20.464]         else {
[17:28:20.464]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.464]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.464]         }
[17:28:20.464]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.464]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.464]             base::sink(type = "output", split = FALSE)
[17:28:20.464]             base::close(...future.stdout)
[17:28:20.464]         }, add = TRUE)
[17:28:20.464]     }
[17:28:20.464]     ...future.frame <- base::sys.nframe()
[17:28:20.464]     ...future.conditions <- base::list()
[17:28:20.464]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.464]     if (FALSE) {
[17:28:20.464]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.464]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.464]     }
[17:28:20.464]     ...future.result <- base::tryCatch({
[17:28:20.464]         base::withCallingHandlers({
[17:28:20.464]             ...future.value <- base::withVisible(base::local({
[17:28:20.464]                 ...future.makeSendCondition <- base::local({
[17:28:20.464]                   sendCondition <- NULL
[17:28:20.464]                   function(frame = 1L) {
[17:28:20.464]                     if (is.function(sendCondition)) 
[17:28:20.464]                       return(sendCondition)
[17:28:20.464]                     ns <- getNamespace("parallel")
[17:28:20.464]                     if (exists("sendData", mode = "function", 
[17:28:20.464]                       envir = ns)) {
[17:28:20.464]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.464]                         envir = ns)
[17:28:20.464]                       envir <- sys.frame(frame)
[17:28:20.464]                       master <- NULL
[17:28:20.464]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.464]                         !identical(envir, emptyenv())) {
[17:28:20.464]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.464]                           inherits = FALSE)) {
[17:28:20.464]                           master <- get("master", mode = "list", 
[17:28:20.464]                             envir = envir, inherits = FALSE)
[17:28:20.464]                           if (inherits(master, c("SOCKnode", 
[17:28:20.464]                             "SOCK0node"))) {
[17:28:20.464]                             sendCondition <<- function(cond) {
[17:28:20.464]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.464]                                 success = TRUE)
[17:28:20.464]                               parallel_sendData(master, data)
[17:28:20.464]                             }
[17:28:20.464]                             return(sendCondition)
[17:28:20.464]                           }
[17:28:20.464]                         }
[17:28:20.464]                         frame <- frame + 1L
[17:28:20.464]                         envir <- sys.frame(frame)
[17:28:20.464]                       }
[17:28:20.464]                     }
[17:28:20.464]                     sendCondition <<- function(cond) NULL
[17:28:20.464]                   }
[17:28:20.464]                 })
[17:28:20.464]                 withCallingHandlers({
[17:28:20.464]                   {
[17:28:20.464]                     sample(x, size = 1L)
[17:28:20.464]                   }
[17:28:20.464]                 }, immediateCondition = function(cond) {
[17:28:20.464]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.464]                   sendCondition(cond)
[17:28:20.464]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.464]                   {
[17:28:20.464]                     inherits <- base::inherits
[17:28:20.464]                     invokeRestart <- base::invokeRestart
[17:28:20.464]                     is.null <- base::is.null
[17:28:20.464]                     muffled <- FALSE
[17:28:20.464]                     if (inherits(cond, "message")) {
[17:28:20.464]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.464]                       if (muffled) 
[17:28:20.464]                         invokeRestart("muffleMessage")
[17:28:20.464]                     }
[17:28:20.464]                     else if (inherits(cond, "warning")) {
[17:28:20.464]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.464]                       if (muffled) 
[17:28:20.464]                         invokeRestart("muffleWarning")
[17:28:20.464]                     }
[17:28:20.464]                     else if (inherits(cond, "condition")) {
[17:28:20.464]                       if (!is.null(pattern)) {
[17:28:20.464]                         computeRestarts <- base::computeRestarts
[17:28:20.464]                         grepl <- base::grepl
[17:28:20.464]                         restarts <- computeRestarts(cond)
[17:28:20.464]                         for (restart in restarts) {
[17:28:20.464]                           name <- restart$name
[17:28:20.464]                           if (is.null(name)) 
[17:28:20.464]                             next
[17:28:20.464]                           if (!grepl(pattern, name)) 
[17:28:20.464]                             next
[17:28:20.464]                           invokeRestart(restart)
[17:28:20.464]                           muffled <- TRUE
[17:28:20.464]                           break
[17:28:20.464]                         }
[17:28:20.464]                       }
[17:28:20.464]                     }
[17:28:20.464]                     invisible(muffled)
[17:28:20.464]                   }
[17:28:20.464]                   muffleCondition(cond)
[17:28:20.464]                 })
[17:28:20.464]             }))
[17:28:20.464]             future::FutureResult(value = ...future.value$value, 
[17:28:20.464]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.464]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.464]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.464]                     ...future.globalenv.names))
[17:28:20.464]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.464]         }, condition = base::local({
[17:28:20.464]             c <- base::c
[17:28:20.464]             inherits <- base::inherits
[17:28:20.464]             invokeRestart <- base::invokeRestart
[17:28:20.464]             length <- base::length
[17:28:20.464]             list <- base::list
[17:28:20.464]             seq.int <- base::seq.int
[17:28:20.464]             signalCondition <- base::signalCondition
[17:28:20.464]             sys.calls <- base::sys.calls
[17:28:20.464]             `[[` <- base::`[[`
[17:28:20.464]             `+` <- base::`+`
[17:28:20.464]             `<<-` <- base::`<<-`
[17:28:20.464]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.464]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.464]                   3L)]
[17:28:20.464]             }
[17:28:20.464]             function(cond) {
[17:28:20.464]                 is_error <- inherits(cond, "error")
[17:28:20.464]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.464]                   NULL)
[17:28:20.464]                 if (is_error) {
[17:28:20.464]                   sessionInformation <- function() {
[17:28:20.464]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.464]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.464]                       search = base::search(), system = base::Sys.info())
[17:28:20.464]                   }
[17:28:20.464]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.464]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.464]                     cond$call), session = sessionInformation(), 
[17:28:20.464]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.464]                   signalCondition(cond)
[17:28:20.464]                 }
[17:28:20.464]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.464]                 "immediateCondition"))) {
[17:28:20.464]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.464]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.464]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.464]                   if (TRUE && !signal) {
[17:28:20.464]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.464]                     {
[17:28:20.464]                       inherits <- base::inherits
[17:28:20.464]                       invokeRestart <- base::invokeRestart
[17:28:20.464]                       is.null <- base::is.null
[17:28:20.464]                       muffled <- FALSE
[17:28:20.464]                       if (inherits(cond, "message")) {
[17:28:20.464]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.464]                         if (muffled) 
[17:28:20.464]                           invokeRestart("muffleMessage")
[17:28:20.464]                       }
[17:28:20.464]                       else if (inherits(cond, "warning")) {
[17:28:20.464]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.464]                         if (muffled) 
[17:28:20.464]                           invokeRestart("muffleWarning")
[17:28:20.464]                       }
[17:28:20.464]                       else if (inherits(cond, "condition")) {
[17:28:20.464]                         if (!is.null(pattern)) {
[17:28:20.464]                           computeRestarts <- base::computeRestarts
[17:28:20.464]                           grepl <- base::grepl
[17:28:20.464]                           restarts <- computeRestarts(cond)
[17:28:20.464]                           for (restart in restarts) {
[17:28:20.464]                             name <- restart$name
[17:28:20.464]                             if (is.null(name)) 
[17:28:20.464]                               next
[17:28:20.464]                             if (!grepl(pattern, name)) 
[17:28:20.464]                               next
[17:28:20.464]                             invokeRestart(restart)
[17:28:20.464]                             muffled <- TRUE
[17:28:20.464]                             break
[17:28:20.464]                           }
[17:28:20.464]                         }
[17:28:20.464]                       }
[17:28:20.464]                       invisible(muffled)
[17:28:20.464]                     }
[17:28:20.464]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.464]                   }
[17:28:20.464]                 }
[17:28:20.464]                 else {
[17:28:20.464]                   if (TRUE) {
[17:28:20.464]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.464]                     {
[17:28:20.464]                       inherits <- base::inherits
[17:28:20.464]                       invokeRestart <- base::invokeRestart
[17:28:20.464]                       is.null <- base::is.null
[17:28:20.464]                       muffled <- FALSE
[17:28:20.464]                       if (inherits(cond, "message")) {
[17:28:20.464]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.464]                         if (muffled) 
[17:28:20.464]                           invokeRestart("muffleMessage")
[17:28:20.464]                       }
[17:28:20.464]                       else if (inherits(cond, "warning")) {
[17:28:20.464]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.464]                         if (muffled) 
[17:28:20.464]                           invokeRestart("muffleWarning")
[17:28:20.464]                       }
[17:28:20.464]                       else if (inherits(cond, "condition")) {
[17:28:20.464]                         if (!is.null(pattern)) {
[17:28:20.464]                           computeRestarts <- base::computeRestarts
[17:28:20.464]                           grepl <- base::grepl
[17:28:20.464]                           restarts <- computeRestarts(cond)
[17:28:20.464]                           for (restart in restarts) {
[17:28:20.464]                             name <- restart$name
[17:28:20.464]                             if (is.null(name)) 
[17:28:20.464]                               next
[17:28:20.464]                             if (!grepl(pattern, name)) 
[17:28:20.464]                               next
[17:28:20.464]                             invokeRestart(restart)
[17:28:20.464]                             muffled <- TRUE
[17:28:20.464]                             break
[17:28:20.464]                           }
[17:28:20.464]                         }
[17:28:20.464]                       }
[17:28:20.464]                       invisible(muffled)
[17:28:20.464]                     }
[17:28:20.464]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.464]                   }
[17:28:20.464]                 }
[17:28:20.464]             }
[17:28:20.464]         }))
[17:28:20.464]     }, error = function(ex) {
[17:28:20.464]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.464]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.464]                 ...future.rng), started = ...future.startTime, 
[17:28:20.464]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.464]             version = "1.8"), class = "FutureResult")
[17:28:20.464]     }, finally = {
[17:28:20.464]         if (!identical(...future.workdir, getwd())) 
[17:28:20.464]             setwd(...future.workdir)
[17:28:20.464]         {
[17:28:20.464]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.464]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.464]             }
[17:28:20.464]             base::options(...future.oldOptions)
[17:28:20.464]             if (.Platform$OS.type == "windows") {
[17:28:20.464]                 old_names <- names(...future.oldEnvVars)
[17:28:20.464]                 envs <- base::Sys.getenv()
[17:28:20.464]                 names <- names(envs)
[17:28:20.464]                 common <- intersect(names, old_names)
[17:28:20.464]                 added <- setdiff(names, old_names)
[17:28:20.464]                 removed <- setdiff(old_names, names)
[17:28:20.464]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.464]                   envs[common]]
[17:28:20.464]                 NAMES <- toupper(changed)
[17:28:20.464]                 args <- list()
[17:28:20.464]                 for (kk in seq_along(NAMES)) {
[17:28:20.464]                   name <- changed[[kk]]
[17:28:20.464]                   NAME <- NAMES[[kk]]
[17:28:20.464]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.464]                     next
[17:28:20.464]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.464]                 }
[17:28:20.464]                 NAMES <- toupper(added)
[17:28:20.464]                 for (kk in seq_along(NAMES)) {
[17:28:20.464]                   name <- added[[kk]]
[17:28:20.464]                   NAME <- NAMES[[kk]]
[17:28:20.464]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.464]                     next
[17:28:20.464]                   args[[name]] <- ""
[17:28:20.464]                 }
[17:28:20.464]                 NAMES <- toupper(removed)
[17:28:20.464]                 for (kk in seq_along(NAMES)) {
[17:28:20.464]                   name <- removed[[kk]]
[17:28:20.464]                   NAME <- NAMES[[kk]]
[17:28:20.464]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.464]                     next
[17:28:20.464]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.464]                 }
[17:28:20.464]                 if (length(args) > 0) 
[17:28:20.464]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.464]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.464]             }
[17:28:20.464]             else {
[17:28:20.464]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.464]             }
[17:28:20.464]             {
[17:28:20.464]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.464]                   0L) {
[17:28:20.464]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.464]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.464]                   base::options(opts)
[17:28:20.464]                 }
[17:28:20.464]                 {
[17:28:20.464]                   {
[17:28:20.464]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.464]                     NULL
[17:28:20.464]                   }
[17:28:20.464]                   options(future.plan = NULL)
[17:28:20.464]                   if (is.na(NA_character_)) 
[17:28:20.464]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.464]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.464]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.464]                     .init = FALSE)
[17:28:20.464]                 }
[17:28:20.464]             }
[17:28:20.464]         }
[17:28:20.464]     })
[17:28:20.464]     if (TRUE) {
[17:28:20.464]         base::sink(type = "output", split = FALSE)
[17:28:20.464]         if (TRUE) {
[17:28:20.464]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.464]         }
[17:28:20.464]         else {
[17:28:20.464]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.464]         }
[17:28:20.464]         base::close(...future.stdout)
[17:28:20.464]         ...future.stdout <- NULL
[17:28:20.464]     }
[17:28:20.464]     ...future.result$conditions <- ...future.conditions
[17:28:20.464]     ...future.result$finished <- base::Sys.time()
[17:28:20.464]     ...future.result
[17:28:20.464] }
[17:28:20.469] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.470] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.470] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.470] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.471] MultisessionFuture started
[17:28:20.471] - Launch lazy future ... done
[17:28:20.471] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-431366'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x0000026672827a38
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:28:20.485] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.485] - Validating connection of MultisessionFuture
[17:28:20.486] - received message: FutureResult
[17:28:20.486] - Received FutureResult
[17:28:20.486] - Erased future from FutureRegistry
[17:28:20.486] result() for ClusterFuture ...
[17:28:20.486] - result already collected: FutureResult
[17:28:20.487] result() for ClusterFuture ... done
[17:28:20.487] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.487] resolve() on list ...
[17:28:20.487]  recursive: 0
[17:28:20.487]  length: 4
[17:28:20.488] 
[17:28:20.488] Future #1
[17:28:20.488] result() for ClusterFuture ...
[17:28:20.488] - result already collected: FutureResult
[17:28:20.488] result() for ClusterFuture ... done
[17:28:20.488] result() for ClusterFuture ...
[17:28:20.488] - result already collected: FutureResult
[17:28:20.489] result() for ClusterFuture ... done
[17:28:20.489] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:28:20.489] - nx: 4
[17:28:20.489] - relay: TRUE
[17:28:20.489] - stdout: TRUE
[17:28:20.490] - signal: TRUE
[17:28:20.490] - resignal: FALSE
[17:28:20.490] - force: TRUE
[17:28:20.490] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:20.490] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:20.490]  - until=1
[17:28:20.491]  - relaying element #1
[17:28:20.491] result() for ClusterFuture ...
[17:28:20.491] - result already collected: FutureResult
[17:28:20.491] result() for ClusterFuture ... done
[17:28:20.491] result() for ClusterFuture ...
[17:28:20.491] - result already collected: FutureResult
[17:28:20.492] result() for ClusterFuture ... done
[17:28:20.492] signalConditions() ...
[17:28:20.492]  - include = 'immediateCondition'
[17:28:20.492]  - exclude = 
[17:28:20.492]  - resignal = FALSE
[17:28:20.492]  - Number of conditions: 1
[17:28:20.492] signalConditions() ... done
[17:28:20.493] result() for ClusterFuture ...
[17:28:20.493] - result already collected: FutureResult
[17:28:20.493] result() for ClusterFuture ... done
[17:28:20.493] signalConditions() ...
[17:28:20.493]  - include = 'immediateCondition'
[17:28:20.493]  - exclude = 
[17:28:20.494]  - resignal = FALSE
[17:28:20.494]  - Number of conditions: 1
[17:28:20.494] signalConditions() ... done
[17:28:20.494] result() for ClusterFuture ...
[17:28:20.494] - result already collected: FutureResult
[17:28:20.494] result() for ClusterFuture ... done
[17:28:20.495] signalConditions() ...
[17:28:20.495]  - include = 'condition'
[17:28:20.495]  - exclude = 'immediateCondition'
[17:28:20.495]  - resignal = TRUE
[17:28:20.495]  - Number of conditions: 1
[17:28:20.495]  - Condition #1: 'RngFutureWarning', 'FutureWarning', 'warning', 'RngFutureCondition', 'FutureCondition', 'condition'
[17:28:20.496] signalConditions() ... done
[17:28:20.496] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:20.496] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:20.496] signalConditionsASAP(MultisessionFuture, pos=1) ... done
<RngFutureWarning: UNRELIABLE VALUE: Future ('fsample_1-163723') 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: 62656bf5-7656-1c89-ee87-4c0c71c42a1a


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

DEBUG: END TROUBLESHOOTING HELP
[17:28:20.497] getGlobalsAndPackages() ...
[17:28:20.497] Searching for globals...
[17:28:20.499] - globals found: [3] '{', 'sample', 'x'
[17:28:20.499] Searching for globals ... DONE
[17:28:20.499] Resolving globals: FALSE
[17:28:20.501] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.502] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.502] - globals: [1] 'x'
[17:28:20.502] 
[17:28:20.502] getGlobalsAndPackages() ... DONE
[17:28:20.503] run() for 'Future' ...
[17:28:20.503] - state: 'created'
[17:28:20.503] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.517] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.517] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.517]   - Field: 'node'
[17:28:20.517]   - Field: 'label'
[17:28:20.517]   - Field: 'local'
[17:28:20.517]   - Field: 'owner'
[17:28:20.518]   - Field: 'envir'
[17:28:20.518]   - Field: 'workers'
[17:28:20.518]   - Field: 'packages'
[17:28:20.518]   - Field: 'gc'
[17:28:20.518]   - Field: 'conditions'
[17:28:20.519]   - Field: 'persistent'
[17:28:20.519]   - Field: 'expr'
[17:28:20.519]   - Field: 'uuid'
[17:28:20.519]   - Field: 'seed'
[17:28:20.519]   - Field: 'version'
[17:28:20.519]   - Field: 'result'
[17:28:20.520]   - Field: 'asynchronous'
[17:28:20.520]   - Field: 'calls'
[17:28:20.520]   - Field: 'globals'
[17:28:20.520]   - Field: 'stdout'
[17:28:20.520]   - Field: 'earlySignal'
[17:28:20.520]   - Field: 'lazy'
[17:28:20.521]   - Field: 'state'
[17:28:20.521] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.521] - Launch lazy future ...
[17:28:20.521] Packages needed by the future expression (n = 0): <none>
[17:28:20.521] Packages needed by future strategies (n = 0): <none>
[17:28:20.522] {
[17:28:20.522]     {
[17:28:20.522]         {
[17:28:20.522]             ...future.startTime <- base::Sys.time()
[17:28:20.522]             {
[17:28:20.522]                 {
[17:28:20.522]                   {
[17:28:20.522]                     {
[17:28:20.522]                       base::local({
[17:28:20.522]                         has_future <- base::requireNamespace("future", 
[17:28:20.522]                           quietly = TRUE)
[17:28:20.522]                         if (has_future) {
[17:28:20.522]                           ns <- base::getNamespace("future")
[17:28:20.522]                           version <- ns[[".package"]][["version"]]
[17:28:20.522]                           if (is.null(version)) 
[17:28:20.522]                             version <- utils::packageVersion("future")
[17:28:20.522]                         }
[17:28:20.522]                         else {
[17:28:20.522]                           version <- NULL
[17:28:20.522]                         }
[17:28:20.522]                         if (!has_future || version < "1.8.0") {
[17:28:20.522]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.522]                             "", base::R.version$version.string), 
[17:28:20.522]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.522]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.522]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.522]                               "release", "version")], collapse = " "), 
[17:28:20.522]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.522]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.522]                             info)
[17:28:20.522]                           info <- base::paste(info, collapse = "; ")
[17:28:20.522]                           if (!has_future) {
[17:28:20.522]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.522]                               info)
[17:28:20.522]                           }
[17:28:20.522]                           else {
[17:28:20.522]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.522]                               info, version)
[17:28:20.522]                           }
[17:28:20.522]                           base::stop(msg)
[17:28:20.522]                         }
[17:28:20.522]                       })
[17:28:20.522]                     }
[17:28:20.522]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.522]                     base::options(mc.cores = 1L)
[17:28:20.522]                   }
[17:28:20.522]                   ...future.strategy.old <- future::plan("list")
[17:28:20.522]                   options(future.plan = NULL)
[17:28:20.522]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.522]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.522]                 }
[17:28:20.522]                 ...future.workdir <- getwd()
[17:28:20.522]             }
[17:28:20.522]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.522]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.522]         }
[17:28:20.522]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.522]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.522]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.522]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.522]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.522]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.522]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.522]             base::names(...future.oldOptions))
[17:28:20.522]     }
[17:28:20.522]     if (FALSE) {
[17:28:20.522]     }
[17:28:20.522]     else {
[17:28:20.522]         if (TRUE) {
[17:28:20.522]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.522]                 open = "w")
[17:28:20.522]         }
[17:28:20.522]         else {
[17:28:20.522]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.522]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.522]         }
[17:28:20.522]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.522]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.522]             base::sink(type = "output", split = FALSE)
[17:28:20.522]             base::close(...future.stdout)
[17:28:20.522]         }, add = TRUE)
[17:28:20.522]     }
[17:28:20.522]     ...future.frame <- base::sys.nframe()
[17:28:20.522]     ...future.conditions <- base::list()
[17:28:20.522]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.522]     if (FALSE) {
[17:28:20.522]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.522]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.522]     }
[17:28:20.522]     ...future.result <- base::tryCatch({
[17:28:20.522]         base::withCallingHandlers({
[17:28:20.522]             ...future.value <- base::withVisible(base::local({
[17:28:20.522]                 ...future.makeSendCondition <- base::local({
[17:28:20.522]                   sendCondition <- NULL
[17:28:20.522]                   function(frame = 1L) {
[17:28:20.522]                     if (is.function(sendCondition)) 
[17:28:20.522]                       return(sendCondition)
[17:28:20.522]                     ns <- getNamespace("parallel")
[17:28:20.522]                     if (exists("sendData", mode = "function", 
[17:28:20.522]                       envir = ns)) {
[17:28:20.522]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.522]                         envir = ns)
[17:28:20.522]                       envir <- sys.frame(frame)
[17:28:20.522]                       master <- NULL
[17:28:20.522]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.522]                         !identical(envir, emptyenv())) {
[17:28:20.522]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.522]                           inherits = FALSE)) {
[17:28:20.522]                           master <- get("master", mode = "list", 
[17:28:20.522]                             envir = envir, inherits = FALSE)
[17:28:20.522]                           if (inherits(master, c("SOCKnode", 
[17:28:20.522]                             "SOCK0node"))) {
[17:28:20.522]                             sendCondition <<- function(cond) {
[17:28:20.522]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.522]                                 success = TRUE)
[17:28:20.522]                               parallel_sendData(master, data)
[17:28:20.522]                             }
[17:28:20.522]                             return(sendCondition)
[17:28:20.522]                           }
[17:28:20.522]                         }
[17:28:20.522]                         frame <- frame + 1L
[17:28:20.522]                         envir <- sys.frame(frame)
[17:28:20.522]                       }
[17:28:20.522]                     }
[17:28:20.522]                     sendCondition <<- function(cond) NULL
[17:28:20.522]                   }
[17:28:20.522]                 })
[17:28:20.522]                 withCallingHandlers({
[17:28:20.522]                   {
[17:28:20.522]                     sample(x, size = 1L)
[17:28:20.522]                   }
[17:28:20.522]                 }, immediateCondition = function(cond) {
[17:28:20.522]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.522]                   sendCondition(cond)
[17:28:20.522]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.522]                   {
[17:28:20.522]                     inherits <- base::inherits
[17:28:20.522]                     invokeRestart <- base::invokeRestart
[17:28:20.522]                     is.null <- base::is.null
[17:28:20.522]                     muffled <- FALSE
[17:28:20.522]                     if (inherits(cond, "message")) {
[17:28:20.522]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.522]                       if (muffled) 
[17:28:20.522]                         invokeRestart("muffleMessage")
[17:28:20.522]                     }
[17:28:20.522]                     else if (inherits(cond, "warning")) {
[17:28:20.522]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.522]                       if (muffled) 
[17:28:20.522]                         invokeRestart("muffleWarning")
[17:28:20.522]                     }
[17:28:20.522]                     else if (inherits(cond, "condition")) {
[17:28:20.522]                       if (!is.null(pattern)) {
[17:28:20.522]                         computeRestarts <- base::computeRestarts
[17:28:20.522]                         grepl <- base::grepl
[17:28:20.522]                         restarts <- computeRestarts(cond)
[17:28:20.522]                         for (restart in restarts) {
[17:28:20.522]                           name <- restart$name
[17:28:20.522]                           if (is.null(name)) 
[17:28:20.522]                             next
[17:28:20.522]                           if (!grepl(pattern, name)) 
[17:28:20.522]                             next
[17:28:20.522]                           invokeRestart(restart)
[17:28:20.522]                           muffled <- TRUE
[17:28:20.522]                           break
[17:28:20.522]                         }
[17:28:20.522]                       }
[17:28:20.522]                     }
[17:28:20.522]                     invisible(muffled)
[17:28:20.522]                   }
[17:28:20.522]                   muffleCondition(cond)
[17:28:20.522]                 })
[17:28:20.522]             }))
[17:28:20.522]             future::FutureResult(value = ...future.value$value, 
[17:28:20.522]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.522]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.522]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.522]                     ...future.globalenv.names))
[17:28:20.522]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.522]         }, condition = base::local({
[17:28:20.522]             c <- base::c
[17:28:20.522]             inherits <- base::inherits
[17:28:20.522]             invokeRestart <- base::invokeRestart
[17:28:20.522]             length <- base::length
[17:28:20.522]             list <- base::list
[17:28:20.522]             seq.int <- base::seq.int
[17:28:20.522]             signalCondition <- base::signalCondition
[17:28:20.522]             sys.calls <- base::sys.calls
[17:28:20.522]             `[[` <- base::`[[`
[17:28:20.522]             `+` <- base::`+`
[17:28:20.522]             `<<-` <- base::`<<-`
[17:28:20.522]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.522]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.522]                   3L)]
[17:28:20.522]             }
[17:28:20.522]             function(cond) {
[17:28:20.522]                 is_error <- inherits(cond, "error")
[17:28:20.522]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.522]                   NULL)
[17:28:20.522]                 if (is_error) {
[17:28:20.522]                   sessionInformation <- function() {
[17:28:20.522]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.522]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.522]                       search = base::search(), system = base::Sys.info())
[17:28:20.522]                   }
[17:28:20.522]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.522]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.522]                     cond$call), session = sessionInformation(), 
[17:28:20.522]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.522]                   signalCondition(cond)
[17:28:20.522]                 }
[17:28:20.522]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.522]                 "immediateCondition"))) {
[17:28:20.522]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.522]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.522]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.522]                   if (TRUE && !signal) {
[17:28:20.522]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.522]                     {
[17:28:20.522]                       inherits <- base::inherits
[17:28:20.522]                       invokeRestart <- base::invokeRestart
[17:28:20.522]                       is.null <- base::is.null
[17:28:20.522]                       muffled <- FALSE
[17:28:20.522]                       if (inherits(cond, "message")) {
[17:28:20.522]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.522]                         if (muffled) 
[17:28:20.522]                           invokeRestart("muffleMessage")
[17:28:20.522]                       }
[17:28:20.522]                       else if (inherits(cond, "warning")) {
[17:28:20.522]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.522]                         if (muffled) 
[17:28:20.522]                           invokeRestart("muffleWarning")
[17:28:20.522]                       }
[17:28:20.522]                       else if (inherits(cond, "condition")) {
[17:28:20.522]                         if (!is.null(pattern)) {
[17:28:20.522]                           computeRestarts <- base::computeRestarts
[17:28:20.522]                           grepl <- base::grepl
[17:28:20.522]                           restarts <- computeRestarts(cond)
[17:28:20.522]                           for (restart in restarts) {
[17:28:20.522]                             name <- restart$name
[17:28:20.522]                             if (is.null(name)) 
[17:28:20.522]                               next
[17:28:20.522]                             if (!grepl(pattern, name)) 
[17:28:20.522]                               next
[17:28:20.522]                             invokeRestart(restart)
[17:28:20.522]                             muffled <- TRUE
[17:28:20.522]                             break
[17:28:20.522]                           }
[17:28:20.522]                         }
[17:28:20.522]                       }
[17:28:20.522]                       invisible(muffled)
[17:28:20.522]                     }
[17:28:20.522]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.522]                   }
[17:28:20.522]                 }
[17:28:20.522]                 else {
[17:28:20.522]                   if (TRUE) {
[17:28:20.522]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.522]                     {
[17:28:20.522]                       inherits <- base::inherits
[17:28:20.522]                       invokeRestart <- base::invokeRestart
[17:28:20.522]                       is.null <- base::is.null
[17:28:20.522]                       muffled <- FALSE
[17:28:20.522]                       if (inherits(cond, "message")) {
[17:28:20.522]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.522]                         if (muffled) 
[17:28:20.522]                           invokeRestart("muffleMessage")
[17:28:20.522]                       }
[17:28:20.522]                       else if (inherits(cond, "warning")) {
[17:28:20.522]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.522]                         if (muffled) 
[17:28:20.522]                           invokeRestart("muffleWarning")
[17:28:20.522]                       }
[17:28:20.522]                       else if (inherits(cond, "condition")) {
[17:28:20.522]                         if (!is.null(pattern)) {
[17:28:20.522]                           computeRestarts <- base::computeRestarts
[17:28:20.522]                           grepl <- base::grepl
[17:28:20.522]                           restarts <- computeRestarts(cond)
[17:28:20.522]                           for (restart in restarts) {
[17:28:20.522]                             name <- restart$name
[17:28:20.522]                             if (is.null(name)) 
[17:28:20.522]                               next
[17:28:20.522]                             if (!grepl(pattern, name)) 
[17:28:20.522]                               next
[17:28:20.522]                             invokeRestart(restart)
[17:28:20.522]                             muffled <- TRUE
[17:28:20.522]                             break
[17:28:20.522]                           }
[17:28:20.522]                         }
[17:28:20.522]                       }
[17:28:20.522]                       invisible(muffled)
[17:28:20.522]                     }
[17:28:20.522]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.522]                   }
[17:28:20.522]                 }
[17:28:20.522]             }
[17:28:20.522]         }))
[17:28:20.522]     }, error = function(ex) {
[17:28:20.522]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.522]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.522]                 ...future.rng), started = ...future.startTime, 
[17:28:20.522]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.522]             version = "1.8"), class = "FutureResult")
[17:28:20.522]     }, finally = {
[17:28:20.522]         if (!identical(...future.workdir, getwd())) 
[17:28:20.522]             setwd(...future.workdir)
[17:28:20.522]         {
[17:28:20.522]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.522]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.522]             }
[17:28:20.522]             base::options(...future.oldOptions)
[17:28:20.522]             if (.Platform$OS.type == "windows") {
[17:28:20.522]                 old_names <- names(...future.oldEnvVars)
[17:28:20.522]                 envs <- base::Sys.getenv()
[17:28:20.522]                 names <- names(envs)
[17:28:20.522]                 common <- intersect(names, old_names)
[17:28:20.522]                 added <- setdiff(names, old_names)
[17:28:20.522]                 removed <- setdiff(old_names, names)
[17:28:20.522]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.522]                   envs[common]]
[17:28:20.522]                 NAMES <- toupper(changed)
[17:28:20.522]                 args <- list()
[17:28:20.522]                 for (kk in seq_along(NAMES)) {
[17:28:20.522]                   name <- changed[[kk]]
[17:28:20.522]                   NAME <- NAMES[[kk]]
[17:28:20.522]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.522]                     next
[17:28:20.522]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.522]                 }
[17:28:20.522]                 NAMES <- toupper(added)
[17:28:20.522]                 for (kk in seq_along(NAMES)) {
[17:28:20.522]                   name <- added[[kk]]
[17:28:20.522]                   NAME <- NAMES[[kk]]
[17:28:20.522]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.522]                     next
[17:28:20.522]                   args[[name]] <- ""
[17:28:20.522]                 }
[17:28:20.522]                 NAMES <- toupper(removed)
[17:28:20.522]                 for (kk in seq_along(NAMES)) {
[17:28:20.522]                   name <- removed[[kk]]
[17:28:20.522]                   NAME <- NAMES[[kk]]
[17:28:20.522]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.522]                     next
[17:28:20.522]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.522]                 }
[17:28:20.522]                 if (length(args) > 0) 
[17:28:20.522]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.522]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.522]             }
[17:28:20.522]             else {
[17:28:20.522]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.522]             }
[17:28:20.522]             {
[17:28:20.522]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.522]                   0L) {
[17:28:20.522]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.522]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.522]                   base::options(opts)
[17:28:20.522]                 }
[17:28:20.522]                 {
[17:28:20.522]                   {
[17:28:20.522]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.522]                     NULL
[17:28:20.522]                   }
[17:28:20.522]                   options(future.plan = NULL)
[17:28:20.522]                   if (is.na(NA_character_)) 
[17:28:20.522]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.522]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.522]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.522]                     .init = FALSE)
[17:28:20.522]                 }
[17:28:20.522]             }
[17:28:20.522]         }
[17:28:20.522]     })
[17:28:20.522]     if (TRUE) {
[17:28:20.522]         base::sink(type = "output", split = FALSE)
[17:28:20.522]         if (TRUE) {
[17:28:20.522]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.522]         }
[17:28:20.522]         else {
[17:28:20.522]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.522]         }
[17:28:20.522]         base::close(...future.stdout)
[17:28:20.522]         ...future.stdout <- NULL
[17:28:20.522]     }
[17:28:20.522]     ...future.result$conditions <- ...future.conditions
[17:28:20.522]     ...future.result$finished <- base::Sys.time()
[17:28:20.522]     ...future.result
[17:28:20.522] }
[17:28:20.527] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.527] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.528] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.528] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.528] MultisessionFuture started
[17:28:20.529] - Launch lazy future ... done
[17:28:20.529] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-162246'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x0000026677a108f0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:28:20.543] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.543] - Validating connection of MultisessionFuture
[17:28:20.543] - received message: FutureResult
[17:28:20.543] - Received FutureResult
[17:28:20.544] - Erased future from FutureRegistry
[17:28:20.544] result() for ClusterFuture ...
[17:28:20.544] - result already collected: FutureResult
[17:28:20.544] result() for ClusterFuture ... done
[17:28:20.544] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.545] getGlobalsAndPackages() ...
[17:28:20.545] Searching for globals...
[17:28:20.546] - globals found: [3] '{', 'sample', 'x'
[17:28:20.546] Searching for globals ... DONE
[17:28:20.546] Resolving globals: FALSE
[17:28:20.547] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.547] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.547] - globals: [1] 'x'
[17:28:20.548] 
[17:28:20.548] getGlobalsAndPackages() ... DONE
[17:28:20.548] run() for 'Future' ...
[17:28:20.548] - state: 'created'
[17:28:20.548] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.563] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.563] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.563]   - Field: 'node'
[17:28:20.563]   - Field: 'label'
[17:28:20.563]   - Field: 'local'
[17:28:20.564]   - Field: 'owner'
[17:28:20.564]   - Field: 'envir'
[17:28:20.564]   - Field: 'workers'
[17:28:20.564]   - Field: 'packages'
[17:28:20.564]   - Field: 'gc'
[17:28:20.564]   - Field: 'conditions'
[17:28:20.565]   - Field: 'persistent'
[17:28:20.565]   - Field: 'expr'
[17:28:20.565]   - Field: 'uuid'
[17:28:20.565]   - Field: 'seed'
[17:28:20.565]   - Field: 'version'
[17:28:20.566]   - Field: 'result'
[17:28:20.566]   - Field: 'asynchronous'
[17:28:20.566]   - Field: 'calls'
[17:28:20.566]   - Field: 'globals'
[17:28:20.566]   - Field: 'stdout'
[17:28:20.566]   - Field: 'earlySignal'
[17:28:20.567]   - Field: 'lazy'
[17:28:20.567]   - Field: 'state'
[17:28:20.567] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.567] - Launch lazy future ...
[17:28:20.567] Packages needed by the future expression (n = 0): <none>
[17:28:20.568] Packages needed by future strategies (n = 0): <none>
[17:28:20.568] {
[17:28:20.568]     {
[17:28:20.568]         {
[17:28:20.568]             ...future.startTime <- base::Sys.time()
[17:28:20.568]             {
[17:28:20.568]                 {
[17:28:20.568]                   {
[17:28:20.568]                     {
[17:28:20.568]                       base::local({
[17:28:20.568]                         has_future <- base::requireNamespace("future", 
[17:28:20.568]                           quietly = TRUE)
[17:28:20.568]                         if (has_future) {
[17:28:20.568]                           ns <- base::getNamespace("future")
[17:28:20.568]                           version <- ns[[".package"]][["version"]]
[17:28:20.568]                           if (is.null(version)) 
[17:28:20.568]                             version <- utils::packageVersion("future")
[17:28:20.568]                         }
[17:28:20.568]                         else {
[17:28:20.568]                           version <- NULL
[17:28:20.568]                         }
[17:28:20.568]                         if (!has_future || version < "1.8.0") {
[17:28:20.568]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.568]                             "", base::R.version$version.string), 
[17:28:20.568]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.568]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.568]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.568]                               "release", "version")], collapse = " "), 
[17:28:20.568]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.568]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.568]                             info)
[17:28:20.568]                           info <- base::paste(info, collapse = "; ")
[17:28:20.568]                           if (!has_future) {
[17:28:20.568]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.568]                               info)
[17:28:20.568]                           }
[17:28:20.568]                           else {
[17:28:20.568]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.568]                               info, version)
[17:28:20.568]                           }
[17:28:20.568]                           base::stop(msg)
[17:28:20.568]                         }
[17:28:20.568]                       })
[17:28:20.568]                     }
[17:28:20.568]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.568]                     base::options(mc.cores = 1L)
[17:28:20.568]                   }
[17:28:20.568]                   ...future.strategy.old <- future::plan("list")
[17:28:20.568]                   options(future.plan = NULL)
[17:28:20.568]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.568]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.568]                 }
[17:28:20.568]                 ...future.workdir <- getwd()
[17:28:20.568]             }
[17:28:20.568]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.568]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.568]         }
[17:28:20.568]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.568]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.568]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.568]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.568]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.568]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.568]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.568]             base::names(...future.oldOptions))
[17:28:20.568]     }
[17:28:20.568]     if (FALSE) {
[17:28:20.568]     }
[17:28:20.568]     else {
[17:28:20.568]         if (TRUE) {
[17:28:20.568]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.568]                 open = "w")
[17:28:20.568]         }
[17:28:20.568]         else {
[17:28:20.568]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.568]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.568]         }
[17:28:20.568]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.568]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.568]             base::sink(type = "output", split = FALSE)
[17:28:20.568]             base::close(...future.stdout)
[17:28:20.568]         }, add = TRUE)
[17:28:20.568]     }
[17:28:20.568]     ...future.frame <- base::sys.nframe()
[17:28:20.568]     ...future.conditions <- base::list()
[17:28:20.568]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.568]     if (FALSE) {
[17:28:20.568]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.568]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.568]     }
[17:28:20.568]     ...future.result <- base::tryCatch({
[17:28:20.568]         base::withCallingHandlers({
[17:28:20.568]             ...future.value <- base::withVisible(base::local({
[17:28:20.568]                 ...future.makeSendCondition <- base::local({
[17:28:20.568]                   sendCondition <- NULL
[17:28:20.568]                   function(frame = 1L) {
[17:28:20.568]                     if (is.function(sendCondition)) 
[17:28:20.568]                       return(sendCondition)
[17:28:20.568]                     ns <- getNamespace("parallel")
[17:28:20.568]                     if (exists("sendData", mode = "function", 
[17:28:20.568]                       envir = ns)) {
[17:28:20.568]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.568]                         envir = ns)
[17:28:20.568]                       envir <- sys.frame(frame)
[17:28:20.568]                       master <- NULL
[17:28:20.568]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.568]                         !identical(envir, emptyenv())) {
[17:28:20.568]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.568]                           inherits = FALSE)) {
[17:28:20.568]                           master <- get("master", mode = "list", 
[17:28:20.568]                             envir = envir, inherits = FALSE)
[17:28:20.568]                           if (inherits(master, c("SOCKnode", 
[17:28:20.568]                             "SOCK0node"))) {
[17:28:20.568]                             sendCondition <<- function(cond) {
[17:28:20.568]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.568]                                 success = TRUE)
[17:28:20.568]                               parallel_sendData(master, data)
[17:28:20.568]                             }
[17:28:20.568]                             return(sendCondition)
[17:28:20.568]                           }
[17:28:20.568]                         }
[17:28:20.568]                         frame <- frame + 1L
[17:28:20.568]                         envir <- sys.frame(frame)
[17:28:20.568]                       }
[17:28:20.568]                     }
[17:28:20.568]                     sendCondition <<- function(cond) NULL
[17:28:20.568]                   }
[17:28:20.568]                 })
[17:28:20.568]                 withCallingHandlers({
[17:28:20.568]                   {
[17:28:20.568]                     sample(x, size = 1L)
[17:28:20.568]                   }
[17:28:20.568]                 }, immediateCondition = function(cond) {
[17:28:20.568]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.568]                   sendCondition(cond)
[17:28:20.568]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.568]                   {
[17:28:20.568]                     inherits <- base::inherits
[17:28:20.568]                     invokeRestart <- base::invokeRestart
[17:28:20.568]                     is.null <- base::is.null
[17:28:20.568]                     muffled <- FALSE
[17:28:20.568]                     if (inherits(cond, "message")) {
[17:28:20.568]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.568]                       if (muffled) 
[17:28:20.568]                         invokeRestart("muffleMessage")
[17:28:20.568]                     }
[17:28:20.568]                     else if (inherits(cond, "warning")) {
[17:28:20.568]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.568]                       if (muffled) 
[17:28:20.568]                         invokeRestart("muffleWarning")
[17:28:20.568]                     }
[17:28:20.568]                     else if (inherits(cond, "condition")) {
[17:28:20.568]                       if (!is.null(pattern)) {
[17:28:20.568]                         computeRestarts <- base::computeRestarts
[17:28:20.568]                         grepl <- base::grepl
[17:28:20.568]                         restarts <- computeRestarts(cond)
[17:28:20.568]                         for (restart in restarts) {
[17:28:20.568]                           name <- restart$name
[17:28:20.568]                           if (is.null(name)) 
[17:28:20.568]                             next
[17:28:20.568]                           if (!grepl(pattern, name)) 
[17:28:20.568]                             next
[17:28:20.568]                           invokeRestart(restart)
[17:28:20.568]                           muffled <- TRUE
[17:28:20.568]                           break
[17:28:20.568]                         }
[17:28:20.568]                       }
[17:28:20.568]                     }
[17:28:20.568]                     invisible(muffled)
[17:28:20.568]                   }
[17:28:20.568]                   muffleCondition(cond)
[17:28:20.568]                 })
[17:28:20.568]             }))
[17:28:20.568]             future::FutureResult(value = ...future.value$value, 
[17:28:20.568]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.568]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.568]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.568]                     ...future.globalenv.names))
[17:28:20.568]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.568]         }, condition = base::local({
[17:28:20.568]             c <- base::c
[17:28:20.568]             inherits <- base::inherits
[17:28:20.568]             invokeRestart <- base::invokeRestart
[17:28:20.568]             length <- base::length
[17:28:20.568]             list <- base::list
[17:28:20.568]             seq.int <- base::seq.int
[17:28:20.568]             signalCondition <- base::signalCondition
[17:28:20.568]             sys.calls <- base::sys.calls
[17:28:20.568]             `[[` <- base::`[[`
[17:28:20.568]             `+` <- base::`+`
[17:28:20.568]             `<<-` <- base::`<<-`
[17:28:20.568]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.568]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.568]                   3L)]
[17:28:20.568]             }
[17:28:20.568]             function(cond) {
[17:28:20.568]                 is_error <- inherits(cond, "error")
[17:28:20.568]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.568]                   NULL)
[17:28:20.568]                 if (is_error) {
[17:28:20.568]                   sessionInformation <- function() {
[17:28:20.568]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.568]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.568]                       search = base::search(), system = base::Sys.info())
[17:28:20.568]                   }
[17:28:20.568]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.568]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.568]                     cond$call), session = sessionInformation(), 
[17:28:20.568]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.568]                   signalCondition(cond)
[17:28:20.568]                 }
[17:28:20.568]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.568]                 "immediateCondition"))) {
[17:28:20.568]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.568]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.568]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.568]                   if (TRUE && !signal) {
[17:28:20.568]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.568]                     {
[17:28:20.568]                       inherits <- base::inherits
[17:28:20.568]                       invokeRestart <- base::invokeRestart
[17:28:20.568]                       is.null <- base::is.null
[17:28:20.568]                       muffled <- FALSE
[17:28:20.568]                       if (inherits(cond, "message")) {
[17:28:20.568]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.568]                         if (muffled) 
[17:28:20.568]                           invokeRestart("muffleMessage")
[17:28:20.568]                       }
[17:28:20.568]                       else if (inherits(cond, "warning")) {
[17:28:20.568]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.568]                         if (muffled) 
[17:28:20.568]                           invokeRestart("muffleWarning")
[17:28:20.568]                       }
[17:28:20.568]                       else if (inherits(cond, "condition")) {
[17:28:20.568]                         if (!is.null(pattern)) {
[17:28:20.568]                           computeRestarts <- base::computeRestarts
[17:28:20.568]                           grepl <- base::grepl
[17:28:20.568]                           restarts <- computeRestarts(cond)
[17:28:20.568]                           for (restart in restarts) {
[17:28:20.568]                             name <- restart$name
[17:28:20.568]                             if (is.null(name)) 
[17:28:20.568]                               next
[17:28:20.568]                             if (!grepl(pattern, name)) 
[17:28:20.568]                               next
[17:28:20.568]                             invokeRestart(restart)
[17:28:20.568]                             muffled <- TRUE
[17:28:20.568]                             break
[17:28:20.568]                           }
[17:28:20.568]                         }
[17:28:20.568]                       }
[17:28:20.568]                       invisible(muffled)
[17:28:20.568]                     }
[17:28:20.568]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.568]                   }
[17:28:20.568]                 }
[17:28:20.568]                 else {
[17:28:20.568]                   if (TRUE) {
[17:28:20.568]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.568]                     {
[17:28:20.568]                       inherits <- base::inherits
[17:28:20.568]                       invokeRestart <- base::invokeRestart
[17:28:20.568]                       is.null <- base::is.null
[17:28:20.568]                       muffled <- FALSE
[17:28:20.568]                       if (inherits(cond, "message")) {
[17:28:20.568]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.568]                         if (muffled) 
[17:28:20.568]                           invokeRestart("muffleMessage")
[17:28:20.568]                       }
[17:28:20.568]                       else if (inherits(cond, "warning")) {
[17:28:20.568]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.568]                         if (muffled) 
[17:28:20.568]                           invokeRestart("muffleWarning")
[17:28:20.568]                       }
[17:28:20.568]                       else if (inherits(cond, "condition")) {
[17:28:20.568]                         if (!is.null(pattern)) {
[17:28:20.568]                           computeRestarts <- base::computeRestarts
[17:28:20.568]                           grepl <- base::grepl
[17:28:20.568]                           restarts <- computeRestarts(cond)
[17:28:20.568]                           for (restart in restarts) {
[17:28:20.568]                             name <- restart$name
[17:28:20.568]                             if (is.null(name)) 
[17:28:20.568]                               next
[17:28:20.568]                             if (!grepl(pattern, name)) 
[17:28:20.568]                               next
[17:28:20.568]                             invokeRestart(restart)
[17:28:20.568]                             muffled <- TRUE
[17:28:20.568]                             break
[17:28:20.568]                           }
[17:28:20.568]                         }
[17:28:20.568]                       }
[17:28:20.568]                       invisible(muffled)
[17:28:20.568]                     }
[17:28:20.568]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.568]                   }
[17:28:20.568]                 }
[17:28:20.568]             }
[17:28:20.568]         }))
[17:28:20.568]     }, error = function(ex) {
[17:28:20.568]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.568]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.568]                 ...future.rng), started = ...future.startTime, 
[17:28:20.568]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.568]             version = "1.8"), class = "FutureResult")
[17:28:20.568]     }, finally = {
[17:28:20.568]         if (!identical(...future.workdir, getwd())) 
[17:28:20.568]             setwd(...future.workdir)
[17:28:20.568]         {
[17:28:20.568]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.568]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.568]             }
[17:28:20.568]             base::options(...future.oldOptions)
[17:28:20.568]             if (.Platform$OS.type == "windows") {
[17:28:20.568]                 old_names <- names(...future.oldEnvVars)
[17:28:20.568]                 envs <- base::Sys.getenv()
[17:28:20.568]                 names <- names(envs)
[17:28:20.568]                 common <- intersect(names, old_names)
[17:28:20.568]                 added <- setdiff(names, old_names)
[17:28:20.568]                 removed <- setdiff(old_names, names)
[17:28:20.568]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.568]                   envs[common]]
[17:28:20.568]                 NAMES <- toupper(changed)
[17:28:20.568]                 args <- list()
[17:28:20.568]                 for (kk in seq_along(NAMES)) {
[17:28:20.568]                   name <- changed[[kk]]
[17:28:20.568]                   NAME <- NAMES[[kk]]
[17:28:20.568]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.568]                     next
[17:28:20.568]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.568]                 }
[17:28:20.568]                 NAMES <- toupper(added)
[17:28:20.568]                 for (kk in seq_along(NAMES)) {
[17:28:20.568]                   name <- added[[kk]]
[17:28:20.568]                   NAME <- NAMES[[kk]]
[17:28:20.568]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.568]                     next
[17:28:20.568]                   args[[name]] <- ""
[17:28:20.568]                 }
[17:28:20.568]                 NAMES <- toupper(removed)
[17:28:20.568]                 for (kk in seq_along(NAMES)) {
[17:28:20.568]                   name <- removed[[kk]]
[17:28:20.568]                   NAME <- NAMES[[kk]]
[17:28:20.568]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.568]                     next
[17:28:20.568]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.568]                 }
[17:28:20.568]                 if (length(args) > 0) 
[17:28:20.568]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.568]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.568]             }
[17:28:20.568]             else {
[17:28:20.568]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.568]             }
[17:28:20.568]             {
[17:28:20.568]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.568]                   0L) {
[17:28:20.568]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.568]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.568]                   base::options(opts)
[17:28:20.568]                 }
[17:28:20.568]                 {
[17:28:20.568]                   {
[17:28:20.568]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.568]                     NULL
[17:28:20.568]                   }
[17:28:20.568]                   options(future.plan = NULL)
[17:28:20.568]                   if (is.na(NA_character_)) 
[17:28:20.568]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.568]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.568]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.568]                     .init = FALSE)
[17:28:20.568]                 }
[17:28:20.568]             }
[17:28:20.568]         }
[17:28:20.568]     })
[17:28:20.568]     if (TRUE) {
[17:28:20.568]         base::sink(type = "output", split = FALSE)
[17:28:20.568]         if (TRUE) {
[17:28:20.568]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.568]         }
[17:28:20.568]         else {
[17:28:20.568]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.568]         }
[17:28:20.568]         base::close(...future.stdout)
[17:28:20.568]         ...future.stdout <- NULL
[17:28:20.568]     }
[17:28:20.568]     ...future.result$conditions <- ...future.conditions
[17:28:20.568]     ...future.result$finished <- base::Sys.time()
[17:28:20.568]     ...future.result
[17:28:20.568] }
[17:28:20.573] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.573] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.574] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.574] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.575] MultisessionFuture started
[17:28:20.575] - Launch lazy future ... done
[17:28:20.575] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-459284'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x0000026677a108f0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:28:20.588] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.588] - Validating connection of MultisessionFuture
[17:28:20.588] - received message: FutureResult
[17:28:20.589] - Received FutureResult
[17:28:20.589] - Erased future from FutureRegistry
[17:28:20.589] result() for ClusterFuture ...
[17:28:20.589] - result already collected: FutureResult
[17:28:20.589] result() for ClusterFuture ... done
[17:28:20.589] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.590] getGlobalsAndPackages() ...
[17:28:20.590] Searching for globals...
[17:28:20.591] - globals found: [3] '{', 'sample', 'x'
[17:28:20.591] Searching for globals ... DONE
[17:28:20.591] Resolving globals: FALSE
[17:28:20.592] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.592] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.592] - globals: [1] 'x'
[17:28:20.593] 
[17:28:20.593] getGlobalsAndPackages() ... DONE
[17:28:20.593] run() for 'Future' ...
[17:28:20.593] - state: 'created'
[17:28:20.593] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.607] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.607] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.607]   - Field: 'node'
[17:28:20.607]   - Field: 'label'
[17:28:20.607]   - Field: 'local'
[17:28:20.608]   - Field: 'owner'
[17:28:20.608]   - Field: 'envir'
[17:28:20.608]   - Field: 'workers'
[17:28:20.608]   - Field: 'packages'
[17:28:20.608]   - Field: 'gc'
[17:28:20.608]   - Field: 'conditions'
[17:28:20.609]   - Field: 'persistent'
[17:28:20.609]   - Field: 'expr'
[17:28:20.609]   - Field: 'uuid'
[17:28:20.609]   - Field: 'seed'
[17:28:20.609]   - Field: 'version'
[17:28:20.610]   - Field: 'result'
[17:28:20.610]   - Field: 'asynchronous'
[17:28:20.610]   - Field: 'calls'
[17:28:20.610]   - Field: 'globals'
[17:28:20.610]   - Field: 'stdout'
[17:28:20.610]   - Field: 'earlySignal'
[17:28:20.611]   - Field: 'lazy'
[17:28:20.611]   - Field: 'state'
[17:28:20.611] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.611] - Launch lazy future ...
[17:28:20.611] Packages needed by the future expression (n = 0): <none>
[17:28:20.612] Packages needed by future strategies (n = 0): <none>
[17:28:20.612] {
[17:28:20.612]     {
[17:28:20.612]         {
[17:28:20.612]             ...future.startTime <- base::Sys.time()
[17:28:20.612]             {
[17:28:20.612]                 {
[17:28:20.612]                   {
[17:28:20.612]                     {
[17:28:20.612]                       base::local({
[17:28:20.612]                         has_future <- base::requireNamespace("future", 
[17:28:20.612]                           quietly = TRUE)
[17:28:20.612]                         if (has_future) {
[17:28:20.612]                           ns <- base::getNamespace("future")
[17:28:20.612]                           version <- ns[[".package"]][["version"]]
[17:28:20.612]                           if (is.null(version)) 
[17:28:20.612]                             version <- utils::packageVersion("future")
[17:28:20.612]                         }
[17:28:20.612]                         else {
[17:28:20.612]                           version <- NULL
[17:28:20.612]                         }
[17:28:20.612]                         if (!has_future || version < "1.8.0") {
[17:28:20.612]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.612]                             "", base::R.version$version.string), 
[17:28:20.612]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.612]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.612]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.612]                               "release", "version")], collapse = " "), 
[17:28:20.612]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.612]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.612]                             info)
[17:28:20.612]                           info <- base::paste(info, collapse = "; ")
[17:28:20.612]                           if (!has_future) {
[17:28:20.612]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.612]                               info)
[17:28:20.612]                           }
[17:28:20.612]                           else {
[17:28:20.612]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.612]                               info, version)
[17:28:20.612]                           }
[17:28:20.612]                           base::stop(msg)
[17:28:20.612]                         }
[17:28:20.612]                       })
[17:28:20.612]                     }
[17:28:20.612]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.612]                     base::options(mc.cores = 1L)
[17:28:20.612]                   }
[17:28:20.612]                   ...future.strategy.old <- future::plan("list")
[17:28:20.612]                   options(future.plan = NULL)
[17:28:20.612]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.612]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.612]                 }
[17:28:20.612]                 ...future.workdir <- getwd()
[17:28:20.612]             }
[17:28:20.612]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.612]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.612]         }
[17:28:20.612]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.612]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.612]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.612]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.612]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.612]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.612]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.612]             base::names(...future.oldOptions))
[17:28:20.612]     }
[17:28:20.612]     if (FALSE) {
[17:28:20.612]     }
[17:28:20.612]     else {
[17:28:20.612]         if (TRUE) {
[17:28:20.612]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.612]                 open = "w")
[17:28:20.612]         }
[17:28:20.612]         else {
[17:28:20.612]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.612]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.612]         }
[17:28:20.612]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.612]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.612]             base::sink(type = "output", split = FALSE)
[17:28:20.612]             base::close(...future.stdout)
[17:28:20.612]         }, add = TRUE)
[17:28:20.612]     }
[17:28:20.612]     ...future.frame <- base::sys.nframe()
[17:28:20.612]     ...future.conditions <- base::list()
[17:28:20.612]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.612]     if (FALSE) {
[17:28:20.612]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.612]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.612]     }
[17:28:20.612]     ...future.result <- base::tryCatch({
[17:28:20.612]         base::withCallingHandlers({
[17:28:20.612]             ...future.value <- base::withVisible(base::local({
[17:28:20.612]                 ...future.makeSendCondition <- base::local({
[17:28:20.612]                   sendCondition <- NULL
[17:28:20.612]                   function(frame = 1L) {
[17:28:20.612]                     if (is.function(sendCondition)) 
[17:28:20.612]                       return(sendCondition)
[17:28:20.612]                     ns <- getNamespace("parallel")
[17:28:20.612]                     if (exists("sendData", mode = "function", 
[17:28:20.612]                       envir = ns)) {
[17:28:20.612]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.612]                         envir = ns)
[17:28:20.612]                       envir <- sys.frame(frame)
[17:28:20.612]                       master <- NULL
[17:28:20.612]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.612]                         !identical(envir, emptyenv())) {
[17:28:20.612]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.612]                           inherits = FALSE)) {
[17:28:20.612]                           master <- get("master", mode = "list", 
[17:28:20.612]                             envir = envir, inherits = FALSE)
[17:28:20.612]                           if (inherits(master, c("SOCKnode", 
[17:28:20.612]                             "SOCK0node"))) {
[17:28:20.612]                             sendCondition <<- function(cond) {
[17:28:20.612]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.612]                                 success = TRUE)
[17:28:20.612]                               parallel_sendData(master, data)
[17:28:20.612]                             }
[17:28:20.612]                             return(sendCondition)
[17:28:20.612]                           }
[17:28:20.612]                         }
[17:28:20.612]                         frame <- frame + 1L
[17:28:20.612]                         envir <- sys.frame(frame)
[17:28:20.612]                       }
[17:28:20.612]                     }
[17:28:20.612]                     sendCondition <<- function(cond) NULL
[17:28:20.612]                   }
[17:28:20.612]                 })
[17:28:20.612]                 withCallingHandlers({
[17:28:20.612]                   {
[17:28:20.612]                     sample(x, size = 1L)
[17:28:20.612]                   }
[17:28:20.612]                 }, immediateCondition = function(cond) {
[17:28:20.612]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.612]                   sendCondition(cond)
[17:28:20.612]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.612]                   {
[17:28:20.612]                     inherits <- base::inherits
[17:28:20.612]                     invokeRestart <- base::invokeRestart
[17:28:20.612]                     is.null <- base::is.null
[17:28:20.612]                     muffled <- FALSE
[17:28:20.612]                     if (inherits(cond, "message")) {
[17:28:20.612]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.612]                       if (muffled) 
[17:28:20.612]                         invokeRestart("muffleMessage")
[17:28:20.612]                     }
[17:28:20.612]                     else if (inherits(cond, "warning")) {
[17:28:20.612]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.612]                       if (muffled) 
[17:28:20.612]                         invokeRestart("muffleWarning")
[17:28:20.612]                     }
[17:28:20.612]                     else if (inherits(cond, "condition")) {
[17:28:20.612]                       if (!is.null(pattern)) {
[17:28:20.612]                         computeRestarts <- base::computeRestarts
[17:28:20.612]                         grepl <- base::grepl
[17:28:20.612]                         restarts <- computeRestarts(cond)
[17:28:20.612]                         for (restart in restarts) {
[17:28:20.612]                           name <- restart$name
[17:28:20.612]                           if (is.null(name)) 
[17:28:20.612]                             next
[17:28:20.612]                           if (!grepl(pattern, name)) 
[17:28:20.612]                             next
[17:28:20.612]                           invokeRestart(restart)
[17:28:20.612]                           muffled <- TRUE
[17:28:20.612]                           break
[17:28:20.612]                         }
[17:28:20.612]                       }
[17:28:20.612]                     }
[17:28:20.612]                     invisible(muffled)
[17:28:20.612]                   }
[17:28:20.612]                   muffleCondition(cond)
[17:28:20.612]                 })
[17:28:20.612]             }))
[17:28:20.612]             future::FutureResult(value = ...future.value$value, 
[17:28:20.612]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.612]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.612]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.612]                     ...future.globalenv.names))
[17:28:20.612]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.612]         }, condition = base::local({
[17:28:20.612]             c <- base::c
[17:28:20.612]             inherits <- base::inherits
[17:28:20.612]             invokeRestart <- base::invokeRestart
[17:28:20.612]             length <- base::length
[17:28:20.612]             list <- base::list
[17:28:20.612]             seq.int <- base::seq.int
[17:28:20.612]             signalCondition <- base::signalCondition
[17:28:20.612]             sys.calls <- base::sys.calls
[17:28:20.612]             `[[` <- base::`[[`
[17:28:20.612]             `+` <- base::`+`
[17:28:20.612]             `<<-` <- base::`<<-`
[17:28:20.612]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.612]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.612]                   3L)]
[17:28:20.612]             }
[17:28:20.612]             function(cond) {
[17:28:20.612]                 is_error <- inherits(cond, "error")
[17:28:20.612]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.612]                   NULL)
[17:28:20.612]                 if (is_error) {
[17:28:20.612]                   sessionInformation <- function() {
[17:28:20.612]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.612]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.612]                       search = base::search(), system = base::Sys.info())
[17:28:20.612]                   }
[17:28:20.612]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.612]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.612]                     cond$call), session = sessionInformation(), 
[17:28:20.612]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.612]                   signalCondition(cond)
[17:28:20.612]                 }
[17:28:20.612]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.612]                 "immediateCondition"))) {
[17:28:20.612]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.612]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.612]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.612]                   if (TRUE && !signal) {
[17:28:20.612]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.612]                     {
[17:28:20.612]                       inherits <- base::inherits
[17:28:20.612]                       invokeRestart <- base::invokeRestart
[17:28:20.612]                       is.null <- base::is.null
[17:28:20.612]                       muffled <- FALSE
[17:28:20.612]                       if (inherits(cond, "message")) {
[17:28:20.612]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.612]                         if (muffled) 
[17:28:20.612]                           invokeRestart("muffleMessage")
[17:28:20.612]                       }
[17:28:20.612]                       else if (inherits(cond, "warning")) {
[17:28:20.612]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.612]                         if (muffled) 
[17:28:20.612]                           invokeRestart("muffleWarning")
[17:28:20.612]                       }
[17:28:20.612]                       else if (inherits(cond, "condition")) {
[17:28:20.612]                         if (!is.null(pattern)) {
[17:28:20.612]                           computeRestarts <- base::computeRestarts
[17:28:20.612]                           grepl <- base::grepl
[17:28:20.612]                           restarts <- computeRestarts(cond)
[17:28:20.612]                           for (restart in restarts) {
[17:28:20.612]                             name <- restart$name
[17:28:20.612]                             if (is.null(name)) 
[17:28:20.612]                               next
[17:28:20.612]                             if (!grepl(pattern, name)) 
[17:28:20.612]                               next
[17:28:20.612]                             invokeRestart(restart)
[17:28:20.612]                             muffled <- TRUE
[17:28:20.612]                             break
[17:28:20.612]                           }
[17:28:20.612]                         }
[17:28:20.612]                       }
[17:28:20.612]                       invisible(muffled)
[17:28:20.612]                     }
[17:28:20.612]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.612]                   }
[17:28:20.612]                 }
[17:28:20.612]                 else {
[17:28:20.612]                   if (TRUE) {
[17:28:20.612]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.612]                     {
[17:28:20.612]                       inherits <- base::inherits
[17:28:20.612]                       invokeRestart <- base::invokeRestart
[17:28:20.612]                       is.null <- base::is.null
[17:28:20.612]                       muffled <- FALSE
[17:28:20.612]                       if (inherits(cond, "message")) {
[17:28:20.612]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.612]                         if (muffled) 
[17:28:20.612]                           invokeRestart("muffleMessage")
[17:28:20.612]                       }
[17:28:20.612]                       else if (inherits(cond, "warning")) {
[17:28:20.612]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.612]                         if (muffled) 
[17:28:20.612]                           invokeRestart("muffleWarning")
[17:28:20.612]                       }
[17:28:20.612]                       else if (inherits(cond, "condition")) {
[17:28:20.612]                         if (!is.null(pattern)) {
[17:28:20.612]                           computeRestarts <- base::computeRestarts
[17:28:20.612]                           grepl <- base::grepl
[17:28:20.612]                           restarts <- computeRestarts(cond)
[17:28:20.612]                           for (restart in restarts) {
[17:28:20.612]                             name <- restart$name
[17:28:20.612]                             if (is.null(name)) 
[17:28:20.612]                               next
[17:28:20.612]                             if (!grepl(pattern, name)) 
[17:28:20.612]                               next
[17:28:20.612]                             invokeRestart(restart)
[17:28:20.612]                             muffled <- TRUE
[17:28:20.612]                             break
[17:28:20.612]                           }
[17:28:20.612]                         }
[17:28:20.612]                       }
[17:28:20.612]                       invisible(muffled)
[17:28:20.612]                     }
[17:28:20.612]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.612]                   }
[17:28:20.612]                 }
[17:28:20.612]             }
[17:28:20.612]         }))
[17:28:20.612]     }, error = function(ex) {
[17:28:20.612]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.612]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.612]                 ...future.rng), started = ...future.startTime, 
[17:28:20.612]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.612]             version = "1.8"), class = "FutureResult")
[17:28:20.612]     }, finally = {
[17:28:20.612]         if (!identical(...future.workdir, getwd())) 
[17:28:20.612]             setwd(...future.workdir)
[17:28:20.612]         {
[17:28:20.612]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.612]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.612]             }
[17:28:20.612]             base::options(...future.oldOptions)
[17:28:20.612]             if (.Platform$OS.type == "windows") {
[17:28:20.612]                 old_names <- names(...future.oldEnvVars)
[17:28:20.612]                 envs <- base::Sys.getenv()
[17:28:20.612]                 names <- names(envs)
[17:28:20.612]                 common <- intersect(names, old_names)
[17:28:20.612]                 added <- setdiff(names, old_names)
[17:28:20.612]                 removed <- setdiff(old_names, names)
[17:28:20.612]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.612]                   envs[common]]
[17:28:20.612]                 NAMES <- toupper(changed)
[17:28:20.612]                 args <- list()
[17:28:20.612]                 for (kk in seq_along(NAMES)) {
[17:28:20.612]                   name <- changed[[kk]]
[17:28:20.612]                   NAME <- NAMES[[kk]]
[17:28:20.612]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.612]                     next
[17:28:20.612]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.612]                 }
[17:28:20.612]                 NAMES <- toupper(added)
[17:28:20.612]                 for (kk in seq_along(NAMES)) {
[17:28:20.612]                   name <- added[[kk]]
[17:28:20.612]                   NAME <- NAMES[[kk]]
[17:28:20.612]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.612]                     next
[17:28:20.612]                   args[[name]] <- ""
[17:28:20.612]                 }
[17:28:20.612]                 NAMES <- toupper(removed)
[17:28:20.612]                 for (kk in seq_along(NAMES)) {
[17:28:20.612]                   name <- removed[[kk]]
[17:28:20.612]                   NAME <- NAMES[[kk]]
[17:28:20.612]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.612]                     next
[17:28:20.612]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.612]                 }
[17:28:20.612]                 if (length(args) > 0) 
[17:28:20.612]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.612]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.612]             }
[17:28:20.612]             else {
[17:28:20.612]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.612]             }
[17:28:20.612]             {
[17:28:20.612]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.612]                   0L) {
[17:28:20.612]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.612]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.612]                   base::options(opts)
[17:28:20.612]                 }
[17:28:20.612]                 {
[17:28:20.612]                   {
[17:28:20.612]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.612]                     NULL
[17:28:20.612]                   }
[17:28:20.612]                   options(future.plan = NULL)
[17:28:20.612]                   if (is.na(NA_character_)) 
[17:28:20.612]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.612]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.612]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.612]                     .init = FALSE)
[17:28:20.612]                 }
[17:28:20.612]             }
[17:28:20.612]         }
[17:28:20.612]     })
[17:28:20.612]     if (TRUE) {
[17:28:20.612]         base::sink(type = "output", split = FALSE)
[17:28:20.612]         if (TRUE) {
[17:28:20.612]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.612]         }
[17:28:20.612]         else {
[17:28:20.612]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.612]         }
[17:28:20.612]         base::close(...future.stdout)
[17:28:20.612]         ...future.stdout <- NULL
[17:28:20.612]     }
[17:28:20.612]     ...future.result$conditions <- ...future.conditions
[17:28:20.612]     ...future.result$finished <- base::Sys.time()
[17:28:20.612]     ...future.result
[17:28:20.612] }
[17:28:20.617] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.617] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.618] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.618] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.619] MultisessionFuture started
[17:28:20.619] - Launch lazy future ... done
[17:28:20.619] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-610160'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x0000026677a108f0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:28:20.633] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.633] - Validating connection of MultisessionFuture
[17:28:20.633] - received message: FutureResult
[17:28:20.633] - Received FutureResult
[17:28:20.634] - Erased future from FutureRegistry
[17:28:20.634] result() for ClusterFuture ...
[17:28:20.634] - result already collected: FutureResult
[17:28:20.634] result() for ClusterFuture ... done
[17:28:20.634] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.635] getGlobalsAndPackages() ...
[17:28:20.635] Searching for globals...
[17:28:20.636] - globals found: [3] '{', 'sample', 'x'
[17:28:20.636] Searching for globals ... DONE
[17:28:20.636] Resolving globals: FALSE
[17:28:20.637] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.637] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.637] - globals: [1] 'x'
[17:28:20.637] 
[17:28:20.638] getGlobalsAndPackages() ... DONE
[17:28:20.638] run() for 'Future' ...
[17:28:20.638] - state: 'created'
[17:28:20.638] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.652] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.652] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.652]   - Field: 'node'
[17:28:20.652]   - Field: 'label'
[17:28:20.652]   - Field: 'local'
[17:28:20.653]   - Field: 'owner'
[17:28:20.653]   - Field: 'envir'
[17:28:20.653]   - Field: 'workers'
[17:28:20.653]   - Field: 'packages'
[17:28:20.653]   - Field: 'gc'
[17:28:20.654]   - Field: 'conditions'
[17:28:20.654]   - Field: 'persistent'
[17:28:20.654]   - Field: 'expr'
[17:28:20.654]   - Field: 'uuid'
[17:28:20.654]   - Field: 'seed'
[17:28:20.654]   - Field: 'version'
[17:28:20.655]   - Field: 'result'
[17:28:20.655]   - Field: 'asynchronous'
[17:28:20.655]   - Field: 'calls'
[17:28:20.655]   - Field: 'globals'
[17:28:20.655]   - Field: 'stdout'
[17:28:20.655]   - Field: 'earlySignal'
[17:28:20.656]   - Field: 'lazy'
[17:28:20.656]   - Field: 'state'
[17:28:20.656] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.656] - Launch lazy future ...
[17:28:20.657] Packages needed by the future expression (n = 0): <none>
[17:28:20.657] Packages needed by future strategies (n = 0): <none>
[17:28:20.657] {
[17:28:20.657]     {
[17:28:20.657]         {
[17:28:20.657]             ...future.startTime <- base::Sys.time()
[17:28:20.657]             {
[17:28:20.657]                 {
[17:28:20.657]                   {
[17:28:20.657]                     {
[17:28:20.657]                       base::local({
[17:28:20.657]                         has_future <- base::requireNamespace("future", 
[17:28:20.657]                           quietly = TRUE)
[17:28:20.657]                         if (has_future) {
[17:28:20.657]                           ns <- base::getNamespace("future")
[17:28:20.657]                           version <- ns[[".package"]][["version"]]
[17:28:20.657]                           if (is.null(version)) 
[17:28:20.657]                             version <- utils::packageVersion("future")
[17:28:20.657]                         }
[17:28:20.657]                         else {
[17:28:20.657]                           version <- NULL
[17:28:20.657]                         }
[17:28:20.657]                         if (!has_future || version < "1.8.0") {
[17:28:20.657]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.657]                             "", base::R.version$version.string), 
[17:28:20.657]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.657]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.657]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.657]                               "release", "version")], collapse = " "), 
[17:28:20.657]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.657]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.657]                             info)
[17:28:20.657]                           info <- base::paste(info, collapse = "; ")
[17:28:20.657]                           if (!has_future) {
[17:28:20.657]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.657]                               info)
[17:28:20.657]                           }
[17:28:20.657]                           else {
[17:28:20.657]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.657]                               info, version)
[17:28:20.657]                           }
[17:28:20.657]                           base::stop(msg)
[17:28:20.657]                         }
[17:28:20.657]                       })
[17:28:20.657]                     }
[17:28:20.657]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.657]                     base::options(mc.cores = 1L)
[17:28:20.657]                   }
[17:28:20.657]                   ...future.strategy.old <- future::plan("list")
[17:28:20.657]                   options(future.plan = NULL)
[17:28:20.657]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.657]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.657]                 }
[17:28:20.657]                 ...future.workdir <- getwd()
[17:28:20.657]             }
[17:28:20.657]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.657]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.657]         }
[17:28:20.657]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.657]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.657]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.657]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.657]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.657]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.657]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.657]             base::names(...future.oldOptions))
[17:28:20.657]     }
[17:28:20.657]     if (FALSE) {
[17:28:20.657]     }
[17:28:20.657]     else {
[17:28:20.657]         if (TRUE) {
[17:28:20.657]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.657]                 open = "w")
[17:28:20.657]         }
[17:28:20.657]         else {
[17:28:20.657]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.657]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.657]         }
[17:28:20.657]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.657]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.657]             base::sink(type = "output", split = FALSE)
[17:28:20.657]             base::close(...future.stdout)
[17:28:20.657]         }, add = TRUE)
[17:28:20.657]     }
[17:28:20.657]     ...future.frame <- base::sys.nframe()
[17:28:20.657]     ...future.conditions <- base::list()
[17:28:20.657]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.657]     if (FALSE) {
[17:28:20.657]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.657]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.657]     }
[17:28:20.657]     ...future.result <- base::tryCatch({
[17:28:20.657]         base::withCallingHandlers({
[17:28:20.657]             ...future.value <- base::withVisible(base::local({
[17:28:20.657]                 ...future.makeSendCondition <- base::local({
[17:28:20.657]                   sendCondition <- NULL
[17:28:20.657]                   function(frame = 1L) {
[17:28:20.657]                     if (is.function(sendCondition)) 
[17:28:20.657]                       return(sendCondition)
[17:28:20.657]                     ns <- getNamespace("parallel")
[17:28:20.657]                     if (exists("sendData", mode = "function", 
[17:28:20.657]                       envir = ns)) {
[17:28:20.657]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.657]                         envir = ns)
[17:28:20.657]                       envir <- sys.frame(frame)
[17:28:20.657]                       master <- NULL
[17:28:20.657]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.657]                         !identical(envir, emptyenv())) {
[17:28:20.657]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.657]                           inherits = FALSE)) {
[17:28:20.657]                           master <- get("master", mode = "list", 
[17:28:20.657]                             envir = envir, inherits = FALSE)
[17:28:20.657]                           if (inherits(master, c("SOCKnode", 
[17:28:20.657]                             "SOCK0node"))) {
[17:28:20.657]                             sendCondition <<- function(cond) {
[17:28:20.657]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.657]                                 success = TRUE)
[17:28:20.657]                               parallel_sendData(master, data)
[17:28:20.657]                             }
[17:28:20.657]                             return(sendCondition)
[17:28:20.657]                           }
[17:28:20.657]                         }
[17:28:20.657]                         frame <- frame + 1L
[17:28:20.657]                         envir <- sys.frame(frame)
[17:28:20.657]                       }
[17:28:20.657]                     }
[17:28:20.657]                     sendCondition <<- function(cond) NULL
[17:28:20.657]                   }
[17:28:20.657]                 })
[17:28:20.657]                 withCallingHandlers({
[17:28:20.657]                   {
[17:28:20.657]                     sample(x, size = 1L)
[17:28:20.657]                   }
[17:28:20.657]                 }, immediateCondition = function(cond) {
[17:28:20.657]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.657]                   sendCondition(cond)
[17:28:20.657]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.657]                   {
[17:28:20.657]                     inherits <- base::inherits
[17:28:20.657]                     invokeRestart <- base::invokeRestart
[17:28:20.657]                     is.null <- base::is.null
[17:28:20.657]                     muffled <- FALSE
[17:28:20.657]                     if (inherits(cond, "message")) {
[17:28:20.657]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.657]                       if (muffled) 
[17:28:20.657]                         invokeRestart("muffleMessage")
[17:28:20.657]                     }
[17:28:20.657]                     else if (inherits(cond, "warning")) {
[17:28:20.657]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.657]                       if (muffled) 
[17:28:20.657]                         invokeRestart("muffleWarning")
[17:28:20.657]                     }
[17:28:20.657]                     else if (inherits(cond, "condition")) {
[17:28:20.657]                       if (!is.null(pattern)) {
[17:28:20.657]                         computeRestarts <- base::computeRestarts
[17:28:20.657]                         grepl <- base::grepl
[17:28:20.657]                         restarts <- computeRestarts(cond)
[17:28:20.657]                         for (restart in restarts) {
[17:28:20.657]                           name <- restart$name
[17:28:20.657]                           if (is.null(name)) 
[17:28:20.657]                             next
[17:28:20.657]                           if (!grepl(pattern, name)) 
[17:28:20.657]                             next
[17:28:20.657]                           invokeRestart(restart)
[17:28:20.657]                           muffled <- TRUE
[17:28:20.657]                           break
[17:28:20.657]                         }
[17:28:20.657]                       }
[17:28:20.657]                     }
[17:28:20.657]                     invisible(muffled)
[17:28:20.657]                   }
[17:28:20.657]                   muffleCondition(cond)
[17:28:20.657]                 })
[17:28:20.657]             }))
[17:28:20.657]             future::FutureResult(value = ...future.value$value, 
[17:28:20.657]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.657]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.657]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.657]                     ...future.globalenv.names))
[17:28:20.657]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.657]         }, condition = base::local({
[17:28:20.657]             c <- base::c
[17:28:20.657]             inherits <- base::inherits
[17:28:20.657]             invokeRestart <- base::invokeRestart
[17:28:20.657]             length <- base::length
[17:28:20.657]             list <- base::list
[17:28:20.657]             seq.int <- base::seq.int
[17:28:20.657]             signalCondition <- base::signalCondition
[17:28:20.657]             sys.calls <- base::sys.calls
[17:28:20.657]             `[[` <- base::`[[`
[17:28:20.657]             `+` <- base::`+`
[17:28:20.657]             `<<-` <- base::`<<-`
[17:28:20.657]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.657]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.657]                   3L)]
[17:28:20.657]             }
[17:28:20.657]             function(cond) {
[17:28:20.657]                 is_error <- inherits(cond, "error")
[17:28:20.657]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.657]                   NULL)
[17:28:20.657]                 if (is_error) {
[17:28:20.657]                   sessionInformation <- function() {
[17:28:20.657]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.657]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.657]                       search = base::search(), system = base::Sys.info())
[17:28:20.657]                   }
[17:28:20.657]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.657]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.657]                     cond$call), session = sessionInformation(), 
[17:28:20.657]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.657]                   signalCondition(cond)
[17:28:20.657]                 }
[17:28:20.657]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.657]                 "immediateCondition"))) {
[17:28:20.657]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.657]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.657]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.657]                   if (TRUE && !signal) {
[17:28:20.657]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.657]                     {
[17:28:20.657]                       inherits <- base::inherits
[17:28:20.657]                       invokeRestart <- base::invokeRestart
[17:28:20.657]                       is.null <- base::is.null
[17:28:20.657]                       muffled <- FALSE
[17:28:20.657]                       if (inherits(cond, "message")) {
[17:28:20.657]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.657]                         if (muffled) 
[17:28:20.657]                           invokeRestart("muffleMessage")
[17:28:20.657]                       }
[17:28:20.657]                       else if (inherits(cond, "warning")) {
[17:28:20.657]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.657]                         if (muffled) 
[17:28:20.657]                           invokeRestart("muffleWarning")
[17:28:20.657]                       }
[17:28:20.657]                       else if (inherits(cond, "condition")) {
[17:28:20.657]                         if (!is.null(pattern)) {
[17:28:20.657]                           computeRestarts <- base::computeRestarts
[17:28:20.657]                           grepl <- base::grepl
[17:28:20.657]                           restarts <- computeRestarts(cond)
[17:28:20.657]                           for (restart in restarts) {
[17:28:20.657]                             name <- restart$name
[17:28:20.657]                             if (is.null(name)) 
[17:28:20.657]                               next
[17:28:20.657]                             if (!grepl(pattern, name)) 
[17:28:20.657]                               next
[17:28:20.657]                             invokeRestart(restart)
[17:28:20.657]                             muffled <- TRUE
[17:28:20.657]                             break
[17:28:20.657]                           }
[17:28:20.657]                         }
[17:28:20.657]                       }
[17:28:20.657]                       invisible(muffled)
[17:28:20.657]                     }
[17:28:20.657]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.657]                   }
[17:28:20.657]                 }
[17:28:20.657]                 else {
[17:28:20.657]                   if (TRUE) {
[17:28:20.657]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.657]                     {
[17:28:20.657]                       inherits <- base::inherits
[17:28:20.657]                       invokeRestart <- base::invokeRestart
[17:28:20.657]                       is.null <- base::is.null
[17:28:20.657]                       muffled <- FALSE
[17:28:20.657]                       if (inherits(cond, "message")) {
[17:28:20.657]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.657]                         if (muffled) 
[17:28:20.657]                           invokeRestart("muffleMessage")
[17:28:20.657]                       }
[17:28:20.657]                       else if (inherits(cond, "warning")) {
[17:28:20.657]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.657]                         if (muffled) 
[17:28:20.657]                           invokeRestart("muffleWarning")
[17:28:20.657]                       }
[17:28:20.657]                       else if (inherits(cond, "condition")) {
[17:28:20.657]                         if (!is.null(pattern)) {
[17:28:20.657]                           computeRestarts <- base::computeRestarts
[17:28:20.657]                           grepl <- base::grepl
[17:28:20.657]                           restarts <- computeRestarts(cond)
[17:28:20.657]                           for (restart in restarts) {
[17:28:20.657]                             name <- restart$name
[17:28:20.657]                             if (is.null(name)) 
[17:28:20.657]                               next
[17:28:20.657]                             if (!grepl(pattern, name)) 
[17:28:20.657]                               next
[17:28:20.657]                             invokeRestart(restart)
[17:28:20.657]                             muffled <- TRUE
[17:28:20.657]                             break
[17:28:20.657]                           }
[17:28:20.657]                         }
[17:28:20.657]                       }
[17:28:20.657]                       invisible(muffled)
[17:28:20.657]                     }
[17:28:20.657]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.657]                   }
[17:28:20.657]                 }
[17:28:20.657]             }
[17:28:20.657]         }))
[17:28:20.657]     }, error = function(ex) {
[17:28:20.657]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.657]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.657]                 ...future.rng), started = ...future.startTime, 
[17:28:20.657]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.657]             version = "1.8"), class = "FutureResult")
[17:28:20.657]     }, finally = {
[17:28:20.657]         if (!identical(...future.workdir, getwd())) 
[17:28:20.657]             setwd(...future.workdir)
[17:28:20.657]         {
[17:28:20.657]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.657]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.657]             }
[17:28:20.657]             base::options(...future.oldOptions)
[17:28:20.657]             if (.Platform$OS.type == "windows") {
[17:28:20.657]                 old_names <- names(...future.oldEnvVars)
[17:28:20.657]                 envs <- base::Sys.getenv()
[17:28:20.657]                 names <- names(envs)
[17:28:20.657]                 common <- intersect(names, old_names)
[17:28:20.657]                 added <- setdiff(names, old_names)
[17:28:20.657]                 removed <- setdiff(old_names, names)
[17:28:20.657]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.657]                   envs[common]]
[17:28:20.657]                 NAMES <- toupper(changed)
[17:28:20.657]                 args <- list()
[17:28:20.657]                 for (kk in seq_along(NAMES)) {
[17:28:20.657]                   name <- changed[[kk]]
[17:28:20.657]                   NAME <- NAMES[[kk]]
[17:28:20.657]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.657]                     next
[17:28:20.657]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.657]                 }
[17:28:20.657]                 NAMES <- toupper(added)
[17:28:20.657]                 for (kk in seq_along(NAMES)) {
[17:28:20.657]                   name <- added[[kk]]
[17:28:20.657]                   NAME <- NAMES[[kk]]
[17:28:20.657]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.657]                     next
[17:28:20.657]                   args[[name]] <- ""
[17:28:20.657]                 }
[17:28:20.657]                 NAMES <- toupper(removed)
[17:28:20.657]                 for (kk in seq_along(NAMES)) {
[17:28:20.657]                   name <- removed[[kk]]
[17:28:20.657]                   NAME <- NAMES[[kk]]
[17:28:20.657]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.657]                     next
[17:28:20.657]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.657]                 }
[17:28:20.657]                 if (length(args) > 0) 
[17:28:20.657]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.657]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.657]             }
[17:28:20.657]             else {
[17:28:20.657]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.657]             }
[17:28:20.657]             {
[17:28:20.657]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.657]                   0L) {
[17:28:20.657]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.657]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.657]                   base::options(opts)
[17:28:20.657]                 }
[17:28:20.657]                 {
[17:28:20.657]                   {
[17:28:20.657]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.657]                     NULL
[17:28:20.657]                   }
[17:28:20.657]                   options(future.plan = NULL)
[17:28:20.657]                   if (is.na(NA_character_)) 
[17:28:20.657]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.657]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.657]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.657]                     .init = FALSE)
[17:28:20.657]                 }
[17:28:20.657]             }
[17:28:20.657]         }
[17:28:20.657]     })
[17:28:20.657]     if (TRUE) {
[17:28:20.657]         base::sink(type = "output", split = FALSE)
[17:28:20.657]         if (TRUE) {
[17:28:20.657]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.657]         }
[17:28:20.657]         else {
[17:28:20.657]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.657]         }
[17:28:20.657]         base::close(...future.stdout)
[17:28:20.657]         ...future.stdout <- NULL
[17:28:20.657]     }
[17:28:20.657]     ...future.result$conditions <- ...future.conditions
[17:28:20.657]     ...future.result$finished <- base::Sys.time()
[17:28:20.657]     ...future.result
[17:28:20.657] }
[17:28:20.662] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.662] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.663] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.663] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.664] MultisessionFuture started
[17:28:20.664] - Launch lazy future ... done
[17:28:20.664] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-855974'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x0000026677a108f0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:28:20.678] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.678] - Validating connection of MultisessionFuture
[17:28:20.678] - received message: FutureResult
[17:28:20.679] - Received FutureResult
[17:28:20.679] - Erased future from FutureRegistry
[17:28:20.679] result() for ClusterFuture ...
[17:28:20.679] - result already collected: FutureResult
[17:28:20.679] result() for ClusterFuture ... done
[17:28:20.679] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.680] resolve() on list ...
[17:28:20.680]  recursive: 0
[17:28:20.680]  length: 4
[17:28:20.680] 
[17:28:20.680] Future #1
[17:28:20.680] result() for ClusterFuture ...
[17:28:20.681] - result already collected: FutureResult
[17:28:20.681] result() for ClusterFuture ... done
[17:28:20.681] result() for ClusterFuture ...
[17:28:20.681] - result already collected: FutureResult
[17:28:20.681] result() for ClusterFuture ... done
[17:28:20.681] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:28:20.682] - nx: 4
[17:28:20.682] - relay: TRUE
[17:28:20.682] - stdout: TRUE
[17:28:20.682] - signal: TRUE
[17:28:20.682] - resignal: FALSE
[17:28:20.682] - force: TRUE
[17:28:20.682] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:20.683] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:20.683]  - until=1
[17:28:20.683]  - relaying element #1
[17:28:20.683] result() for ClusterFuture ...
[17:28:20.683] - result already collected: FutureResult
[17:28:20.683] result() for ClusterFuture ... done
[17:28:20.684] result() for ClusterFuture ...
[17:28:20.684] - result already collected: FutureResult
[17:28:20.684] result() for ClusterFuture ... done
[17:28:20.684] result() for ClusterFuture ...
[17:28:20.684] - result already collected: FutureResult
[17:28:20.684] result() for ClusterFuture ... done
[17:28:20.685] result() for ClusterFuture ...
[17:28:20.685] - result already collected: FutureResult
[17:28:20.685] result() for ClusterFuture ... done
[17:28:20.685] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:20.685] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:20.685] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[17:28:20.686]  length: 3 (resolved future 1)
[17:28:20.686] Future #2
[17:28:20.686] result() for ClusterFuture ...
[17:28:20.686] - result already collected: FutureResult
[17:28:20.686] result() for ClusterFuture ... done
[17:28:20.686] result() for ClusterFuture ...
[17:28:20.687] - result already collected: FutureResult
[17:28:20.687] result() for ClusterFuture ... done
[17:28:20.687] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:28:20.687] - nx: 4
[17:28:20.687] - relay: TRUE
[17:28:20.687] - stdout: TRUE
[17:28:20.687] - signal: TRUE
[17:28:20.688] - resignal: FALSE
[17:28:20.688] - force: TRUE
[17:28:20.688] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:20.688] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:20.688]  - until=2
[17:28:20.688]  - relaying element #2
[17:28:20.689] result() for ClusterFuture ...
[17:28:20.689] - result already collected: FutureResult
[17:28:20.689] result() for ClusterFuture ... done
[17:28:20.689] result() for ClusterFuture ...
[17:28:20.689] - result already collected: FutureResult
[17:28:20.689] result() for ClusterFuture ... done
[17:28:20.690] result() for ClusterFuture ...
[17:28:20.690] - result already collected: FutureResult
[17:28:20.690] result() for ClusterFuture ... done
[17:28:20.690] result() for ClusterFuture ...
[17:28:20.690] - result already collected: FutureResult
[17:28:20.690] result() for ClusterFuture ... done
[17:28:20.690] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:20.691] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:20.691] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:28:20.691]  length: 2 (resolved future 2)
[17:28:20.691] Future #3
[17:28:20.691] result() for ClusterFuture ...
[17:28:20.691] - result already collected: FutureResult
[17:28:20.692] result() for ClusterFuture ... done
[17:28:20.692] result() for ClusterFuture ...
[17:28:20.692] - result already collected: FutureResult
[17:28:20.692] result() for ClusterFuture ... done
[17:28:20.692] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:28:20.692] - nx: 4
[17:28:20.693] - relay: TRUE
[17:28:20.693] - stdout: TRUE
[17:28:20.693] - signal: TRUE
[17:28:20.693] - resignal: FALSE
[17:28:20.693] - force: TRUE
[17:28:20.693] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:20.693] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:20.694]  - until=3
[17:28:20.694]  - relaying element #3
[17:28:20.694] result() for ClusterFuture ...
[17:28:20.694] - result already collected: FutureResult
[17:28:20.694] result() for ClusterFuture ... done
[17:28:20.694] result() for ClusterFuture ...
[17:28:20.695] - result already collected: FutureResult
[17:28:20.695] result() for ClusterFuture ... done
[17:28:20.695] result() for ClusterFuture ...
[17:28:20.695] - result already collected: FutureResult
[17:28:20.695] result() for ClusterFuture ... done
[17:28:20.695] result() for ClusterFuture ...
[17:28:20.696] - result already collected: FutureResult
[17:28:20.696] result() for ClusterFuture ... done
[17:28:20.696] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:20.696] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:20.696] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:28:20.696]  length: 1 (resolved future 3)
[17:28:20.696] Future #4
[17:28:20.697] result() for ClusterFuture ...
[17:28:20.697] - result already collected: FutureResult
[17:28:20.697] result() for ClusterFuture ... done
[17:28:20.697] result() for ClusterFuture ...
[17:28:20.697] - result already collected: FutureResult
[17:28:20.697] result() for ClusterFuture ... done
[17:28:20.698] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:28:20.698] - nx: 4
[17:28:20.698] - relay: TRUE
[17:28:20.698] - stdout: TRUE
[17:28:20.698] - signal: TRUE
[17:28:20.698] - resignal: FALSE
[17:28:20.698] - force: TRUE
[17:28:20.699] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:20.699] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:20.699]  - until=4
[17:28:20.699]  - relaying element #4
[17:28:20.699] result() for ClusterFuture ...
[17:28:20.699] - result already collected: FutureResult
[17:28:20.700] result() for ClusterFuture ... done
[17:28:20.700] result() for ClusterFuture ...
[17:28:20.700] - result already collected: FutureResult
[17:28:20.700] result() for ClusterFuture ... done
[17:28:20.700] result() for ClusterFuture ...
[17:28:20.700] - result already collected: FutureResult
[17:28:20.701] result() for ClusterFuture ... done
[17:28:20.701] result() for ClusterFuture ...
[17:28:20.701] - result already collected: FutureResult
[17:28:20.701] result() for ClusterFuture ... done
[17:28:20.701] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:20.701] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:20.701] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:28:20.702]  length: 0 (resolved future 4)
[17:28:20.702] Relaying remaining futures
[17:28:20.702] signalConditionsASAP(NULL, pos=0) ...
[17:28:20.702] - nx: 4
[17:28:20.702] - relay: TRUE
[17:28:20.703] - stdout: TRUE
[17:28:20.703] - signal: TRUE
[17:28:20.703] - resignal: FALSE
[17:28:20.703] - force: TRUE
[17:28:20.703] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:20.703] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:28:20.704] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:20.704] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:20.704] signalConditionsASAP(NULL, pos=0) ... done
[17:28:20.704] resolve() on list ... DONE
[17:28:20.704] result() for ClusterFuture ...
[17:28:20.704] - result already collected: FutureResult
[17:28:20.705] result() for ClusterFuture ... done
[17:28:20.705] result() for ClusterFuture ...
[17:28:20.705] - result already collected: FutureResult
[17:28:20.705] result() for ClusterFuture ... done
[17:28:20.705] result() for ClusterFuture ...
[17:28:20.705] - result already collected: FutureResult
[17:28:20.705] result() for ClusterFuture ... done
[17:28:20.706] result() for ClusterFuture ...
[17:28:20.706] - result already collected: FutureResult
[17:28:20.706] result() for ClusterFuture ... done
[17:28:20.706] result() for ClusterFuture ...
[17:28:20.706] - result already collected: FutureResult
[17:28:20.706] result() for ClusterFuture ... done
[17:28:20.707] result() for ClusterFuture ...
[17:28:20.707] - result already collected: FutureResult
[17:28:20.707] result() for ClusterFuture ... done
[17:28:20.707] result() for ClusterFuture ...
[17:28:20.707] - result already collected: FutureResult
[17:28:20.707] result() for ClusterFuture ... done
[17:28:20.708] result() for ClusterFuture ...
[17:28:20.708] - result already collected: FutureResult
[17:28:20.708] result() for ClusterFuture ... done
[[1]]
[1] 3

[[2]]
[1] 2

[[3]]
[1] 0

[[4]]
[1] 0

[17:28:20.708] getGlobalsAndPackages() ...
[17:28:20.708] Searching for globals...
[17:28:20.710] - globals found: [3] '{', 'sample', 'x'
[17:28:20.710] Searching for globals ... DONE
[17:28:20.710] Resolving globals: FALSE
[17:28:20.710] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.711] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.711] - globals: [1] 'x'
[17:28:20.711] 
[17:28:20.711] getGlobalsAndPackages() ... DONE
[17:28:20.712] run() for 'Future' ...
[17:28:20.712] - state: 'created'
[17:28:20.712] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.726] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.726] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.726]   - Field: 'node'
[17:28:20.726]   - Field: 'label'
[17:28:20.726]   - Field: 'local'
[17:28:20.726]   - Field: 'owner'
[17:28:20.727]   - Field: 'envir'
[17:28:20.727]   - Field: 'workers'
[17:28:20.727]   - Field: 'packages'
[17:28:20.727]   - Field: 'gc'
[17:28:20.727]   - Field: 'conditions'
[17:28:20.728]   - Field: 'persistent'
[17:28:20.728]   - Field: 'expr'
[17:28:20.728]   - Field: 'uuid'
[17:28:20.728]   - Field: 'seed'
[17:28:20.728]   - Field: 'version'
[17:28:20.728]   - Field: 'result'
[17:28:20.729]   - Field: 'asynchronous'
[17:28:20.729]   - Field: 'calls'
[17:28:20.729]   - Field: 'globals'
[17:28:20.729]   - Field: 'stdout'
[17:28:20.729]   - Field: 'earlySignal'
[17:28:20.731]   - Field: 'lazy'
[17:28:20.732]   - Field: 'state'
[17:28:20.732] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.732] - Launch lazy future ...
[17:28:20.732] Packages needed by the future expression (n = 0): <none>
[17:28:20.733] Packages needed by future strategies (n = 0): <none>
[17:28:20.733] {
[17:28:20.733]     {
[17:28:20.733]         {
[17:28:20.733]             ...future.startTime <- base::Sys.time()
[17:28:20.733]             {
[17:28:20.733]                 {
[17:28:20.733]                   {
[17:28:20.733]                     {
[17:28:20.733]                       base::local({
[17:28:20.733]                         has_future <- base::requireNamespace("future", 
[17:28:20.733]                           quietly = TRUE)
[17:28:20.733]                         if (has_future) {
[17:28:20.733]                           ns <- base::getNamespace("future")
[17:28:20.733]                           version <- ns[[".package"]][["version"]]
[17:28:20.733]                           if (is.null(version)) 
[17:28:20.733]                             version <- utils::packageVersion("future")
[17:28:20.733]                         }
[17:28:20.733]                         else {
[17:28:20.733]                           version <- NULL
[17:28:20.733]                         }
[17:28:20.733]                         if (!has_future || version < "1.8.0") {
[17:28:20.733]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.733]                             "", base::R.version$version.string), 
[17:28:20.733]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.733]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.733]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.733]                               "release", "version")], collapse = " "), 
[17:28:20.733]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.733]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.733]                             info)
[17:28:20.733]                           info <- base::paste(info, collapse = "; ")
[17:28:20.733]                           if (!has_future) {
[17:28:20.733]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.733]                               info)
[17:28:20.733]                           }
[17:28:20.733]                           else {
[17:28:20.733]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.733]                               info, version)
[17:28:20.733]                           }
[17:28:20.733]                           base::stop(msg)
[17:28:20.733]                         }
[17:28:20.733]                       })
[17:28:20.733]                     }
[17:28:20.733]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.733]                     base::options(mc.cores = 1L)
[17:28:20.733]                   }
[17:28:20.733]                   ...future.strategy.old <- future::plan("list")
[17:28:20.733]                   options(future.plan = NULL)
[17:28:20.733]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.733]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.733]                 }
[17:28:20.733]                 ...future.workdir <- getwd()
[17:28:20.733]             }
[17:28:20.733]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.733]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.733]         }
[17:28:20.733]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.733]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.733]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.733]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.733]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.733]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.733]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.733]             base::names(...future.oldOptions))
[17:28:20.733]     }
[17:28:20.733]     if (FALSE) {
[17:28:20.733]     }
[17:28:20.733]     else {
[17:28:20.733]         if (TRUE) {
[17:28:20.733]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.733]                 open = "w")
[17:28:20.733]         }
[17:28:20.733]         else {
[17:28:20.733]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.733]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.733]         }
[17:28:20.733]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.733]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.733]             base::sink(type = "output", split = FALSE)
[17:28:20.733]             base::close(...future.stdout)
[17:28:20.733]         }, add = TRUE)
[17:28:20.733]     }
[17:28:20.733]     ...future.frame <- base::sys.nframe()
[17:28:20.733]     ...future.conditions <- base::list()
[17:28:20.733]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.733]     if (FALSE) {
[17:28:20.733]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.733]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.733]     }
[17:28:20.733]     ...future.result <- base::tryCatch({
[17:28:20.733]         base::withCallingHandlers({
[17:28:20.733]             ...future.value <- base::withVisible(base::local({
[17:28:20.733]                 ...future.makeSendCondition <- base::local({
[17:28:20.733]                   sendCondition <- NULL
[17:28:20.733]                   function(frame = 1L) {
[17:28:20.733]                     if (is.function(sendCondition)) 
[17:28:20.733]                       return(sendCondition)
[17:28:20.733]                     ns <- getNamespace("parallel")
[17:28:20.733]                     if (exists("sendData", mode = "function", 
[17:28:20.733]                       envir = ns)) {
[17:28:20.733]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.733]                         envir = ns)
[17:28:20.733]                       envir <- sys.frame(frame)
[17:28:20.733]                       master <- NULL
[17:28:20.733]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.733]                         !identical(envir, emptyenv())) {
[17:28:20.733]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.733]                           inherits = FALSE)) {
[17:28:20.733]                           master <- get("master", mode = "list", 
[17:28:20.733]                             envir = envir, inherits = FALSE)
[17:28:20.733]                           if (inherits(master, c("SOCKnode", 
[17:28:20.733]                             "SOCK0node"))) {
[17:28:20.733]                             sendCondition <<- function(cond) {
[17:28:20.733]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.733]                                 success = TRUE)
[17:28:20.733]                               parallel_sendData(master, data)
[17:28:20.733]                             }
[17:28:20.733]                             return(sendCondition)
[17:28:20.733]                           }
[17:28:20.733]                         }
[17:28:20.733]                         frame <- frame + 1L
[17:28:20.733]                         envir <- sys.frame(frame)
[17:28:20.733]                       }
[17:28:20.733]                     }
[17:28:20.733]                     sendCondition <<- function(cond) NULL
[17:28:20.733]                   }
[17:28:20.733]                 })
[17:28:20.733]                 withCallingHandlers({
[17:28:20.733]                   {
[17:28:20.733]                     sample(x, size = 1L)
[17:28:20.733]                   }
[17:28:20.733]                 }, immediateCondition = function(cond) {
[17:28:20.733]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.733]                   sendCondition(cond)
[17:28:20.733]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.733]                   {
[17:28:20.733]                     inherits <- base::inherits
[17:28:20.733]                     invokeRestart <- base::invokeRestart
[17:28:20.733]                     is.null <- base::is.null
[17:28:20.733]                     muffled <- FALSE
[17:28:20.733]                     if (inherits(cond, "message")) {
[17:28:20.733]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.733]                       if (muffled) 
[17:28:20.733]                         invokeRestart("muffleMessage")
[17:28:20.733]                     }
[17:28:20.733]                     else if (inherits(cond, "warning")) {
[17:28:20.733]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.733]                       if (muffled) 
[17:28:20.733]                         invokeRestart("muffleWarning")
[17:28:20.733]                     }
[17:28:20.733]                     else if (inherits(cond, "condition")) {
[17:28:20.733]                       if (!is.null(pattern)) {
[17:28:20.733]                         computeRestarts <- base::computeRestarts
[17:28:20.733]                         grepl <- base::grepl
[17:28:20.733]                         restarts <- computeRestarts(cond)
[17:28:20.733]                         for (restart in restarts) {
[17:28:20.733]                           name <- restart$name
[17:28:20.733]                           if (is.null(name)) 
[17:28:20.733]                             next
[17:28:20.733]                           if (!grepl(pattern, name)) 
[17:28:20.733]                             next
[17:28:20.733]                           invokeRestart(restart)
[17:28:20.733]                           muffled <- TRUE
[17:28:20.733]                           break
[17:28:20.733]                         }
[17:28:20.733]                       }
[17:28:20.733]                     }
[17:28:20.733]                     invisible(muffled)
[17:28:20.733]                   }
[17:28:20.733]                   muffleCondition(cond)
[17:28:20.733]                 })
[17:28:20.733]             }))
[17:28:20.733]             future::FutureResult(value = ...future.value$value, 
[17:28:20.733]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.733]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.733]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.733]                     ...future.globalenv.names))
[17:28:20.733]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.733]         }, condition = base::local({
[17:28:20.733]             c <- base::c
[17:28:20.733]             inherits <- base::inherits
[17:28:20.733]             invokeRestart <- base::invokeRestart
[17:28:20.733]             length <- base::length
[17:28:20.733]             list <- base::list
[17:28:20.733]             seq.int <- base::seq.int
[17:28:20.733]             signalCondition <- base::signalCondition
[17:28:20.733]             sys.calls <- base::sys.calls
[17:28:20.733]             `[[` <- base::`[[`
[17:28:20.733]             `+` <- base::`+`
[17:28:20.733]             `<<-` <- base::`<<-`
[17:28:20.733]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.733]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.733]                   3L)]
[17:28:20.733]             }
[17:28:20.733]             function(cond) {
[17:28:20.733]                 is_error <- inherits(cond, "error")
[17:28:20.733]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.733]                   NULL)
[17:28:20.733]                 if (is_error) {
[17:28:20.733]                   sessionInformation <- function() {
[17:28:20.733]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.733]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.733]                       search = base::search(), system = base::Sys.info())
[17:28:20.733]                   }
[17:28:20.733]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.733]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.733]                     cond$call), session = sessionInformation(), 
[17:28:20.733]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.733]                   signalCondition(cond)
[17:28:20.733]                 }
[17:28:20.733]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.733]                 "immediateCondition"))) {
[17:28:20.733]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.733]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.733]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.733]                   if (TRUE && !signal) {
[17:28:20.733]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.733]                     {
[17:28:20.733]                       inherits <- base::inherits
[17:28:20.733]                       invokeRestart <- base::invokeRestart
[17:28:20.733]                       is.null <- base::is.null
[17:28:20.733]                       muffled <- FALSE
[17:28:20.733]                       if (inherits(cond, "message")) {
[17:28:20.733]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.733]                         if (muffled) 
[17:28:20.733]                           invokeRestart("muffleMessage")
[17:28:20.733]                       }
[17:28:20.733]                       else if (inherits(cond, "warning")) {
[17:28:20.733]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.733]                         if (muffled) 
[17:28:20.733]                           invokeRestart("muffleWarning")
[17:28:20.733]                       }
[17:28:20.733]                       else if (inherits(cond, "condition")) {
[17:28:20.733]                         if (!is.null(pattern)) {
[17:28:20.733]                           computeRestarts <- base::computeRestarts
[17:28:20.733]                           grepl <- base::grepl
[17:28:20.733]                           restarts <- computeRestarts(cond)
[17:28:20.733]                           for (restart in restarts) {
[17:28:20.733]                             name <- restart$name
[17:28:20.733]                             if (is.null(name)) 
[17:28:20.733]                               next
[17:28:20.733]                             if (!grepl(pattern, name)) 
[17:28:20.733]                               next
[17:28:20.733]                             invokeRestart(restart)
[17:28:20.733]                             muffled <- TRUE
[17:28:20.733]                             break
[17:28:20.733]                           }
[17:28:20.733]                         }
[17:28:20.733]                       }
[17:28:20.733]                       invisible(muffled)
[17:28:20.733]                     }
[17:28:20.733]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.733]                   }
[17:28:20.733]                 }
[17:28:20.733]                 else {
[17:28:20.733]                   if (TRUE) {
[17:28:20.733]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.733]                     {
[17:28:20.733]                       inherits <- base::inherits
[17:28:20.733]                       invokeRestart <- base::invokeRestart
[17:28:20.733]                       is.null <- base::is.null
[17:28:20.733]                       muffled <- FALSE
[17:28:20.733]                       if (inherits(cond, "message")) {
[17:28:20.733]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.733]                         if (muffled) 
[17:28:20.733]                           invokeRestart("muffleMessage")
[17:28:20.733]                       }
[17:28:20.733]                       else if (inherits(cond, "warning")) {
[17:28:20.733]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.733]                         if (muffled) 
[17:28:20.733]                           invokeRestart("muffleWarning")
[17:28:20.733]                       }
[17:28:20.733]                       else if (inherits(cond, "condition")) {
[17:28:20.733]                         if (!is.null(pattern)) {
[17:28:20.733]                           computeRestarts <- base::computeRestarts
[17:28:20.733]                           grepl <- base::grepl
[17:28:20.733]                           restarts <- computeRestarts(cond)
[17:28:20.733]                           for (restart in restarts) {
[17:28:20.733]                             name <- restart$name
[17:28:20.733]                             if (is.null(name)) 
[17:28:20.733]                               next
[17:28:20.733]                             if (!grepl(pattern, name)) 
[17:28:20.733]                               next
[17:28:20.733]                             invokeRestart(restart)
[17:28:20.733]                             muffled <- TRUE
[17:28:20.733]                             break
[17:28:20.733]                           }
[17:28:20.733]                         }
[17:28:20.733]                       }
[17:28:20.733]                       invisible(muffled)
[17:28:20.733]                     }
[17:28:20.733]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.733]                   }
[17:28:20.733]                 }
[17:28:20.733]             }
[17:28:20.733]         }))
[17:28:20.733]     }, error = function(ex) {
[17:28:20.733]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.733]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.733]                 ...future.rng), started = ...future.startTime, 
[17:28:20.733]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.733]             version = "1.8"), class = "FutureResult")
[17:28:20.733]     }, finally = {
[17:28:20.733]         if (!identical(...future.workdir, getwd())) 
[17:28:20.733]             setwd(...future.workdir)
[17:28:20.733]         {
[17:28:20.733]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.733]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.733]             }
[17:28:20.733]             base::options(...future.oldOptions)
[17:28:20.733]             if (.Platform$OS.type == "windows") {
[17:28:20.733]                 old_names <- names(...future.oldEnvVars)
[17:28:20.733]                 envs <- base::Sys.getenv()
[17:28:20.733]                 names <- names(envs)
[17:28:20.733]                 common <- intersect(names, old_names)
[17:28:20.733]                 added <- setdiff(names, old_names)
[17:28:20.733]                 removed <- setdiff(old_names, names)
[17:28:20.733]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.733]                   envs[common]]
[17:28:20.733]                 NAMES <- toupper(changed)
[17:28:20.733]                 args <- list()
[17:28:20.733]                 for (kk in seq_along(NAMES)) {
[17:28:20.733]                   name <- changed[[kk]]
[17:28:20.733]                   NAME <- NAMES[[kk]]
[17:28:20.733]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.733]                     next
[17:28:20.733]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.733]                 }
[17:28:20.733]                 NAMES <- toupper(added)
[17:28:20.733]                 for (kk in seq_along(NAMES)) {
[17:28:20.733]                   name <- added[[kk]]
[17:28:20.733]                   NAME <- NAMES[[kk]]
[17:28:20.733]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.733]                     next
[17:28:20.733]                   args[[name]] <- ""
[17:28:20.733]                 }
[17:28:20.733]                 NAMES <- toupper(removed)
[17:28:20.733]                 for (kk in seq_along(NAMES)) {
[17:28:20.733]                   name <- removed[[kk]]
[17:28:20.733]                   NAME <- NAMES[[kk]]
[17:28:20.733]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.733]                     next
[17:28:20.733]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.733]                 }
[17:28:20.733]                 if (length(args) > 0) 
[17:28:20.733]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.733]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.733]             }
[17:28:20.733]             else {
[17:28:20.733]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.733]             }
[17:28:20.733]             {
[17:28:20.733]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.733]                   0L) {
[17:28:20.733]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.733]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.733]                   base::options(opts)
[17:28:20.733]                 }
[17:28:20.733]                 {
[17:28:20.733]                   {
[17:28:20.733]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.733]                     NULL
[17:28:20.733]                   }
[17:28:20.733]                   options(future.plan = NULL)
[17:28:20.733]                   if (is.na(NA_character_)) 
[17:28:20.733]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.733]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.733]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.733]                     .init = FALSE)
[17:28:20.733]                 }
[17:28:20.733]             }
[17:28:20.733]         }
[17:28:20.733]     })
[17:28:20.733]     if (TRUE) {
[17:28:20.733]         base::sink(type = "output", split = FALSE)
[17:28:20.733]         if (TRUE) {
[17:28:20.733]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.733]         }
[17:28:20.733]         else {
[17:28:20.733]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.733]         }
[17:28:20.733]         base::close(...future.stdout)
[17:28:20.733]         ...future.stdout <- NULL
[17:28:20.733]     }
[17:28:20.733]     ...future.result$conditions <- ...future.conditions
[17:28:20.733]     ...future.result$finished <- base::Sys.time()
[17:28:20.733]     ...future.result
[17:28:20.733] }
[17:28:20.738] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.738] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.739] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.739] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.739] MultisessionFuture started
[17:28:20.740] - Launch lazy future ... done
[17:28:20.740] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-316434'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x00000266775329d0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:28:20.754] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.754] - Validating connection of MultisessionFuture
[17:28:20.754] - received message: FutureResult
[17:28:20.754] - Received FutureResult
[17:28:20.755] - Erased future from FutureRegistry
[17:28:20.755] result() for ClusterFuture ...
[17:28:20.755] - result already collected: FutureResult
[17:28:20.755] result() for ClusterFuture ... done
[17:28:20.755] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.755] getGlobalsAndPackages() ...
[17:28:20.756] Searching for globals...
[17:28:20.757] - globals found: [3] '{', 'sample', 'x'
[17:28:20.757] Searching for globals ... DONE
[17:28:20.757] Resolving globals: FALSE
[17:28:20.758] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.758] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.758] - globals: [1] 'x'
[17:28:20.758] 
[17:28:20.759] getGlobalsAndPackages() ... DONE
[17:28:20.759] run() for 'Future' ...
[17:28:20.759] - state: 'created'
[17:28:20.759] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.773] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.773] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.773]   - Field: 'node'
[17:28:20.774]   - Field: 'label'
[17:28:20.774]   - Field: 'local'
[17:28:20.774]   - Field: 'owner'
[17:28:20.774]   - Field: 'envir'
[17:28:20.774]   - Field: 'workers'
[17:28:20.775]   - Field: 'packages'
[17:28:20.775]   - Field: 'gc'
[17:28:20.775]   - Field: 'conditions'
[17:28:20.775]   - Field: 'persistent'
[17:28:20.775]   - Field: 'expr'
[17:28:20.775]   - Field: 'uuid'
[17:28:20.776]   - Field: 'seed'
[17:28:20.776]   - Field: 'version'
[17:28:20.776]   - Field: 'result'
[17:28:20.776]   - Field: 'asynchronous'
[17:28:20.776]   - Field: 'calls'
[17:28:20.776]   - Field: 'globals'
[17:28:20.777]   - Field: 'stdout'
[17:28:20.777]   - Field: 'earlySignal'
[17:28:20.777]   - Field: 'lazy'
[17:28:20.777]   - Field: 'state'
[17:28:20.777] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.777] - Launch lazy future ...
[17:28:20.778] Packages needed by the future expression (n = 0): <none>
[17:28:20.778] Packages needed by future strategies (n = 0): <none>
[17:28:20.779] {
[17:28:20.779]     {
[17:28:20.779]         {
[17:28:20.779]             ...future.startTime <- base::Sys.time()
[17:28:20.779]             {
[17:28:20.779]                 {
[17:28:20.779]                   {
[17:28:20.779]                     {
[17:28:20.779]                       base::local({
[17:28:20.779]                         has_future <- base::requireNamespace("future", 
[17:28:20.779]                           quietly = TRUE)
[17:28:20.779]                         if (has_future) {
[17:28:20.779]                           ns <- base::getNamespace("future")
[17:28:20.779]                           version <- ns[[".package"]][["version"]]
[17:28:20.779]                           if (is.null(version)) 
[17:28:20.779]                             version <- utils::packageVersion("future")
[17:28:20.779]                         }
[17:28:20.779]                         else {
[17:28:20.779]                           version <- NULL
[17:28:20.779]                         }
[17:28:20.779]                         if (!has_future || version < "1.8.0") {
[17:28:20.779]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.779]                             "", base::R.version$version.string), 
[17:28:20.779]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.779]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.779]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.779]                               "release", "version")], collapse = " "), 
[17:28:20.779]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.779]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.779]                             info)
[17:28:20.779]                           info <- base::paste(info, collapse = "; ")
[17:28:20.779]                           if (!has_future) {
[17:28:20.779]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.779]                               info)
[17:28:20.779]                           }
[17:28:20.779]                           else {
[17:28:20.779]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.779]                               info, version)
[17:28:20.779]                           }
[17:28:20.779]                           base::stop(msg)
[17:28:20.779]                         }
[17:28:20.779]                       })
[17:28:20.779]                     }
[17:28:20.779]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.779]                     base::options(mc.cores = 1L)
[17:28:20.779]                   }
[17:28:20.779]                   ...future.strategy.old <- future::plan("list")
[17:28:20.779]                   options(future.plan = NULL)
[17:28:20.779]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.779]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.779]                 }
[17:28:20.779]                 ...future.workdir <- getwd()
[17:28:20.779]             }
[17:28:20.779]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.779]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.779]         }
[17:28:20.779]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.779]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.779]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.779]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.779]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.779]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.779]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.779]             base::names(...future.oldOptions))
[17:28:20.779]     }
[17:28:20.779]     if (FALSE) {
[17:28:20.779]     }
[17:28:20.779]     else {
[17:28:20.779]         if (TRUE) {
[17:28:20.779]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.779]                 open = "w")
[17:28:20.779]         }
[17:28:20.779]         else {
[17:28:20.779]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.779]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.779]         }
[17:28:20.779]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.779]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.779]             base::sink(type = "output", split = FALSE)
[17:28:20.779]             base::close(...future.stdout)
[17:28:20.779]         }, add = TRUE)
[17:28:20.779]     }
[17:28:20.779]     ...future.frame <- base::sys.nframe()
[17:28:20.779]     ...future.conditions <- base::list()
[17:28:20.779]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.779]     if (FALSE) {
[17:28:20.779]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.779]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.779]     }
[17:28:20.779]     ...future.result <- base::tryCatch({
[17:28:20.779]         base::withCallingHandlers({
[17:28:20.779]             ...future.value <- base::withVisible(base::local({
[17:28:20.779]                 ...future.makeSendCondition <- base::local({
[17:28:20.779]                   sendCondition <- NULL
[17:28:20.779]                   function(frame = 1L) {
[17:28:20.779]                     if (is.function(sendCondition)) 
[17:28:20.779]                       return(sendCondition)
[17:28:20.779]                     ns <- getNamespace("parallel")
[17:28:20.779]                     if (exists("sendData", mode = "function", 
[17:28:20.779]                       envir = ns)) {
[17:28:20.779]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.779]                         envir = ns)
[17:28:20.779]                       envir <- sys.frame(frame)
[17:28:20.779]                       master <- NULL
[17:28:20.779]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.779]                         !identical(envir, emptyenv())) {
[17:28:20.779]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.779]                           inherits = FALSE)) {
[17:28:20.779]                           master <- get("master", mode = "list", 
[17:28:20.779]                             envir = envir, inherits = FALSE)
[17:28:20.779]                           if (inherits(master, c("SOCKnode", 
[17:28:20.779]                             "SOCK0node"))) {
[17:28:20.779]                             sendCondition <<- function(cond) {
[17:28:20.779]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.779]                                 success = TRUE)
[17:28:20.779]                               parallel_sendData(master, data)
[17:28:20.779]                             }
[17:28:20.779]                             return(sendCondition)
[17:28:20.779]                           }
[17:28:20.779]                         }
[17:28:20.779]                         frame <- frame + 1L
[17:28:20.779]                         envir <- sys.frame(frame)
[17:28:20.779]                       }
[17:28:20.779]                     }
[17:28:20.779]                     sendCondition <<- function(cond) NULL
[17:28:20.779]                   }
[17:28:20.779]                 })
[17:28:20.779]                 withCallingHandlers({
[17:28:20.779]                   {
[17:28:20.779]                     sample(x, size = 1L)
[17:28:20.779]                   }
[17:28:20.779]                 }, immediateCondition = function(cond) {
[17:28:20.779]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.779]                   sendCondition(cond)
[17:28:20.779]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.779]                   {
[17:28:20.779]                     inherits <- base::inherits
[17:28:20.779]                     invokeRestart <- base::invokeRestart
[17:28:20.779]                     is.null <- base::is.null
[17:28:20.779]                     muffled <- FALSE
[17:28:20.779]                     if (inherits(cond, "message")) {
[17:28:20.779]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.779]                       if (muffled) 
[17:28:20.779]                         invokeRestart("muffleMessage")
[17:28:20.779]                     }
[17:28:20.779]                     else if (inherits(cond, "warning")) {
[17:28:20.779]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.779]                       if (muffled) 
[17:28:20.779]                         invokeRestart("muffleWarning")
[17:28:20.779]                     }
[17:28:20.779]                     else if (inherits(cond, "condition")) {
[17:28:20.779]                       if (!is.null(pattern)) {
[17:28:20.779]                         computeRestarts <- base::computeRestarts
[17:28:20.779]                         grepl <- base::grepl
[17:28:20.779]                         restarts <- computeRestarts(cond)
[17:28:20.779]                         for (restart in restarts) {
[17:28:20.779]                           name <- restart$name
[17:28:20.779]                           if (is.null(name)) 
[17:28:20.779]                             next
[17:28:20.779]                           if (!grepl(pattern, name)) 
[17:28:20.779]                             next
[17:28:20.779]                           invokeRestart(restart)
[17:28:20.779]                           muffled <- TRUE
[17:28:20.779]                           break
[17:28:20.779]                         }
[17:28:20.779]                       }
[17:28:20.779]                     }
[17:28:20.779]                     invisible(muffled)
[17:28:20.779]                   }
[17:28:20.779]                   muffleCondition(cond)
[17:28:20.779]                 })
[17:28:20.779]             }))
[17:28:20.779]             future::FutureResult(value = ...future.value$value, 
[17:28:20.779]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.779]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.779]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.779]                     ...future.globalenv.names))
[17:28:20.779]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.779]         }, condition = base::local({
[17:28:20.779]             c <- base::c
[17:28:20.779]             inherits <- base::inherits
[17:28:20.779]             invokeRestart <- base::invokeRestart
[17:28:20.779]             length <- base::length
[17:28:20.779]             list <- base::list
[17:28:20.779]             seq.int <- base::seq.int
[17:28:20.779]             signalCondition <- base::signalCondition
[17:28:20.779]             sys.calls <- base::sys.calls
[17:28:20.779]             `[[` <- base::`[[`
[17:28:20.779]             `+` <- base::`+`
[17:28:20.779]             `<<-` <- base::`<<-`
[17:28:20.779]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.779]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.779]                   3L)]
[17:28:20.779]             }
[17:28:20.779]             function(cond) {
[17:28:20.779]                 is_error <- inherits(cond, "error")
[17:28:20.779]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.779]                   NULL)
[17:28:20.779]                 if (is_error) {
[17:28:20.779]                   sessionInformation <- function() {
[17:28:20.779]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.779]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.779]                       search = base::search(), system = base::Sys.info())
[17:28:20.779]                   }
[17:28:20.779]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.779]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.779]                     cond$call), session = sessionInformation(), 
[17:28:20.779]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.779]                   signalCondition(cond)
[17:28:20.779]                 }
[17:28:20.779]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.779]                 "immediateCondition"))) {
[17:28:20.779]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.779]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.779]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.779]                   if (TRUE && !signal) {
[17:28:20.779]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.779]                     {
[17:28:20.779]                       inherits <- base::inherits
[17:28:20.779]                       invokeRestart <- base::invokeRestart
[17:28:20.779]                       is.null <- base::is.null
[17:28:20.779]                       muffled <- FALSE
[17:28:20.779]                       if (inherits(cond, "message")) {
[17:28:20.779]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.779]                         if (muffled) 
[17:28:20.779]                           invokeRestart("muffleMessage")
[17:28:20.779]                       }
[17:28:20.779]                       else if (inherits(cond, "warning")) {
[17:28:20.779]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.779]                         if (muffled) 
[17:28:20.779]                           invokeRestart("muffleWarning")
[17:28:20.779]                       }
[17:28:20.779]                       else if (inherits(cond, "condition")) {
[17:28:20.779]                         if (!is.null(pattern)) {
[17:28:20.779]                           computeRestarts <- base::computeRestarts
[17:28:20.779]                           grepl <- base::grepl
[17:28:20.779]                           restarts <- computeRestarts(cond)
[17:28:20.779]                           for (restart in restarts) {
[17:28:20.779]                             name <- restart$name
[17:28:20.779]                             if (is.null(name)) 
[17:28:20.779]                               next
[17:28:20.779]                             if (!grepl(pattern, name)) 
[17:28:20.779]                               next
[17:28:20.779]                             invokeRestart(restart)
[17:28:20.779]                             muffled <- TRUE
[17:28:20.779]                             break
[17:28:20.779]                           }
[17:28:20.779]                         }
[17:28:20.779]                       }
[17:28:20.779]                       invisible(muffled)
[17:28:20.779]                     }
[17:28:20.779]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.779]                   }
[17:28:20.779]                 }
[17:28:20.779]                 else {
[17:28:20.779]                   if (TRUE) {
[17:28:20.779]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.779]                     {
[17:28:20.779]                       inherits <- base::inherits
[17:28:20.779]                       invokeRestart <- base::invokeRestart
[17:28:20.779]                       is.null <- base::is.null
[17:28:20.779]                       muffled <- FALSE
[17:28:20.779]                       if (inherits(cond, "message")) {
[17:28:20.779]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.779]                         if (muffled) 
[17:28:20.779]                           invokeRestart("muffleMessage")
[17:28:20.779]                       }
[17:28:20.779]                       else if (inherits(cond, "warning")) {
[17:28:20.779]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.779]                         if (muffled) 
[17:28:20.779]                           invokeRestart("muffleWarning")
[17:28:20.779]                       }
[17:28:20.779]                       else if (inherits(cond, "condition")) {
[17:28:20.779]                         if (!is.null(pattern)) {
[17:28:20.779]                           computeRestarts <- base::computeRestarts
[17:28:20.779]                           grepl <- base::grepl
[17:28:20.779]                           restarts <- computeRestarts(cond)
[17:28:20.779]                           for (restart in restarts) {
[17:28:20.779]                             name <- restart$name
[17:28:20.779]                             if (is.null(name)) 
[17:28:20.779]                               next
[17:28:20.779]                             if (!grepl(pattern, name)) 
[17:28:20.779]                               next
[17:28:20.779]                             invokeRestart(restart)
[17:28:20.779]                             muffled <- TRUE
[17:28:20.779]                             break
[17:28:20.779]                           }
[17:28:20.779]                         }
[17:28:20.779]                       }
[17:28:20.779]                       invisible(muffled)
[17:28:20.779]                     }
[17:28:20.779]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.779]                   }
[17:28:20.779]                 }
[17:28:20.779]             }
[17:28:20.779]         }))
[17:28:20.779]     }, error = function(ex) {
[17:28:20.779]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.779]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.779]                 ...future.rng), started = ...future.startTime, 
[17:28:20.779]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.779]             version = "1.8"), class = "FutureResult")
[17:28:20.779]     }, finally = {
[17:28:20.779]         if (!identical(...future.workdir, getwd())) 
[17:28:20.779]             setwd(...future.workdir)
[17:28:20.779]         {
[17:28:20.779]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.779]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.779]             }
[17:28:20.779]             base::options(...future.oldOptions)
[17:28:20.779]             if (.Platform$OS.type == "windows") {
[17:28:20.779]                 old_names <- names(...future.oldEnvVars)
[17:28:20.779]                 envs <- base::Sys.getenv()
[17:28:20.779]                 names <- names(envs)
[17:28:20.779]                 common <- intersect(names, old_names)
[17:28:20.779]                 added <- setdiff(names, old_names)
[17:28:20.779]                 removed <- setdiff(old_names, names)
[17:28:20.779]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.779]                   envs[common]]
[17:28:20.779]                 NAMES <- toupper(changed)
[17:28:20.779]                 args <- list()
[17:28:20.779]                 for (kk in seq_along(NAMES)) {
[17:28:20.779]                   name <- changed[[kk]]
[17:28:20.779]                   NAME <- NAMES[[kk]]
[17:28:20.779]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.779]                     next
[17:28:20.779]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.779]                 }
[17:28:20.779]                 NAMES <- toupper(added)
[17:28:20.779]                 for (kk in seq_along(NAMES)) {
[17:28:20.779]                   name <- added[[kk]]
[17:28:20.779]                   NAME <- NAMES[[kk]]
[17:28:20.779]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.779]                     next
[17:28:20.779]                   args[[name]] <- ""
[17:28:20.779]                 }
[17:28:20.779]                 NAMES <- toupper(removed)
[17:28:20.779]                 for (kk in seq_along(NAMES)) {
[17:28:20.779]                   name <- removed[[kk]]
[17:28:20.779]                   NAME <- NAMES[[kk]]
[17:28:20.779]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.779]                     next
[17:28:20.779]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.779]                 }
[17:28:20.779]                 if (length(args) > 0) 
[17:28:20.779]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.779]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.779]             }
[17:28:20.779]             else {
[17:28:20.779]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.779]             }
[17:28:20.779]             {
[17:28:20.779]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.779]                   0L) {
[17:28:20.779]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.779]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.779]                   base::options(opts)
[17:28:20.779]                 }
[17:28:20.779]                 {
[17:28:20.779]                   {
[17:28:20.779]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.779]                     NULL
[17:28:20.779]                   }
[17:28:20.779]                   options(future.plan = NULL)
[17:28:20.779]                   if (is.na(NA_character_)) 
[17:28:20.779]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.779]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.779]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.779]                     .init = FALSE)
[17:28:20.779]                 }
[17:28:20.779]             }
[17:28:20.779]         }
[17:28:20.779]     })
[17:28:20.779]     if (TRUE) {
[17:28:20.779]         base::sink(type = "output", split = FALSE)
[17:28:20.779]         if (TRUE) {
[17:28:20.779]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.779]         }
[17:28:20.779]         else {
[17:28:20.779]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.779]         }
[17:28:20.779]         base::close(...future.stdout)
[17:28:20.779]         ...future.stdout <- NULL
[17:28:20.779]     }
[17:28:20.779]     ...future.result$conditions <- ...future.conditions
[17:28:20.779]     ...future.result$finished <- base::Sys.time()
[17:28:20.779]     ...future.result
[17:28:20.779] }
[17:28:20.784] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.784] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.784] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.785] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.785] MultisessionFuture started
[17:28:20.785] - Launch lazy future ... done
[17:28:20.785] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-987891'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x00000266775329d0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:28:20.799] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.799] - Validating connection of MultisessionFuture
[17:28:20.799] - received message: FutureResult
[17:28:20.799] - Received FutureResult
[17:28:20.799] - Erased future from FutureRegistry
[17:28:20.800] result() for ClusterFuture ...
[17:28:20.800] - result already collected: FutureResult
[17:28:20.800] result() for ClusterFuture ... done
[17:28:20.800] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.800] getGlobalsAndPackages() ...
[17:28:20.801] Searching for globals...
[17:28:20.802] - globals found: [3] '{', 'sample', 'x'
[17:28:20.802] Searching for globals ... DONE
[17:28:20.802] Resolving globals: FALSE
[17:28:20.803] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.803] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.803] - globals: [1] 'x'
[17:28:20.803] 
[17:28:20.803] getGlobalsAndPackages() ... DONE
[17:28:20.804] run() for 'Future' ...
[17:28:20.804] - state: 'created'
[17:28:20.804] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.818] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.818] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.819]   - Field: 'node'
[17:28:20.819]   - Field: 'label'
[17:28:20.819]   - Field: 'local'
[17:28:20.819]   - Field: 'owner'
[17:28:20.819]   - Field: 'envir'
[17:28:20.820]   - Field: 'workers'
[17:28:20.820]   - Field: 'packages'
[17:28:20.820]   - Field: 'gc'
[17:28:20.820]   - Field: 'conditions'
[17:28:20.820]   - Field: 'persistent'
[17:28:20.820]   - Field: 'expr'
[17:28:20.821]   - Field: 'uuid'
[17:28:20.821]   - Field: 'seed'
[17:28:20.821]   - Field: 'version'
[17:28:20.821]   - Field: 'result'
[17:28:20.821]   - Field: 'asynchronous'
[17:28:20.821]   - Field: 'calls'
[17:28:20.822]   - Field: 'globals'
[17:28:20.822]   - Field: 'stdout'
[17:28:20.822]   - Field: 'earlySignal'
[17:28:20.822]   - Field: 'lazy'
[17:28:20.822]   - Field: 'state'
[17:28:20.823] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.823] - Launch lazy future ...
[17:28:20.823] Packages needed by the future expression (n = 0): <none>
[17:28:20.823] Packages needed by future strategies (n = 0): <none>
[17:28:20.824] {
[17:28:20.824]     {
[17:28:20.824]         {
[17:28:20.824]             ...future.startTime <- base::Sys.time()
[17:28:20.824]             {
[17:28:20.824]                 {
[17:28:20.824]                   {
[17:28:20.824]                     {
[17:28:20.824]                       base::local({
[17:28:20.824]                         has_future <- base::requireNamespace("future", 
[17:28:20.824]                           quietly = TRUE)
[17:28:20.824]                         if (has_future) {
[17:28:20.824]                           ns <- base::getNamespace("future")
[17:28:20.824]                           version <- ns[[".package"]][["version"]]
[17:28:20.824]                           if (is.null(version)) 
[17:28:20.824]                             version <- utils::packageVersion("future")
[17:28:20.824]                         }
[17:28:20.824]                         else {
[17:28:20.824]                           version <- NULL
[17:28:20.824]                         }
[17:28:20.824]                         if (!has_future || version < "1.8.0") {
[17:28:20.824]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.824]                             "", base::R.version$version.string), 
[17:28:20.824]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.824]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.824]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.824]                               "release", "version")], collapse = " "), 
[17:28:20.824]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.824]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.824]                             info)
[17:28:20.824]                           info <- base::paste(info, collapse = "; ")
[17:28:20.824]                           if (!has_future) {
[17:28:20.824]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.824]                               info)
[17:28:20.824]                           }
[17:28:20.824]                           else {
[17:28:20.824]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.824]                               info, version)
[17:28:20.824]                           }
[17:28:20.824]                           base::stop(msg)
[17:28:20.824]                         }
[17:28:20.824]                       })
[17:28:20.824]                     }
[17:28:20.824]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.824]                     base::options(mc.cores = 1L)
[17:28:20.824]                   }
[17:28:20.824]                   ...future.strategy.old <- future::plan("list")
[17:28:20.824]                   options(future.plan = NULL)
[17:28:20.824]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.824]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.824]                 }
[17:28:20.824]                 ...future.workdir <- getwd()
[17:28:20.824]             }
[17:28:20.824]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.824]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.824]         }
[17:28:20.824]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.824]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.824]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.824]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.824]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.824]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.824]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.824]             base::names(...future.oldOptions))
[17:28:20.824]     }
[17:28:20.824]     if (FALSE) {
[17:28:20.824]     }
[17:28:20.824]     else {
[17:28:20.824]         if (TRUE) {
[17:28:20.824]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.824]                 open = "w")
[17:28:20.824]         }
[17:28:20.824]         else {
[17:28:20.824]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.824]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.824]         }
[17:28:20.824]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.824]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.824]             base::sink(type = "output", split = FALSE)
[17:28:20.824]             base::close(...future.stdout)
[17:28:20.824]         }, add = TRUE)
[17:28:20.824]     }
[17:28:20.824]     ...future.frame <- base::sys.nframe()
[17:28:20.824]     ...future.conditions <- base::list()
[17:28:20.824]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.824]     if (FALSE) {
[17:28:20.824]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.824]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.824]     }
[17:28:20.824]     ...future.result <- base::tryCatch({
[17:28:20.824]         base::withCallingHandlers({
[17:28:20.824]             ...future.value <- base::withVisible(base::local({
[17:28:20.824]                 ...future.makeSendCondition <- base::local({
[17:28:20.824]                   sendCondition <- NULL
[17:28:20.824]                   function(frame = 1L) {
[17:28:20.824]                     if (is.function(sendCondition)) 
[17:28:20.824]                       return(sendCondition)
[17:28:20.824]                     ns <- getNamespace("parallel")
[17:28:20.824]                     if (exists("sendData", mode = "function", 
[17:28:20.824]                       envir = ns)) {
[17:28:20.824]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.824]                         envir = ns)
[17:28:20.824]                       envir <- sys.frame(frame)
[17:28:20.824]                       master <- NULL
[17:28:20.824]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.824]                         !identical(envir, emptyenv())) {
[17:28:20.824]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.824]                           inherits = FALSE)) {
[17:28:20.824]                           master <- get("master", mode = "list", 
[17:28:20.824]                             envir = envir, inherits = FALSE)
[17:28:20.824]                           if (inherits(master, c("SOCKnode", 
[17:28:20.824]                             "SOCK0node"))) {
[17:28:20.824]                             sendCondition <<- function(cond) {
[17:28:20.824]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.824]                                 success = TRUE)
[17:28:20.824]                               parallel_sendData(master, data)
[17:28:20.824]                             }
[17:28:20.824]                             return(sendCondition)
[17:28:20.824]                           }
[17:28:20.824]                         }
[17:28:20.824]                         frame <- frame + 1L
[17:28:20.824]                         envir <- sys.frame(frame)
[17:28:20.824]                       }
[17:28:20.824]                     }
[17:28:20.824]                     sendCondition <<- function(cond) NULL
[17:28:20.824]                   }
[17:28:20.824]                 })
[17:28:20.824]                 withCallingHandlers({
[17:28:20.824]                   {
[17:28:20.824]                     sample(x, size = 1L)
[17:28:20.824]                   }
[17:28:20.824]                 }, immediateCondition = function(cond) {
[17:28:20.824]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.824]                   sendCondition(cond)
[17:28:20.824]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.824]                   {
[17:28:20.824]                     inherits <- base::inherits
[17:28:20.824]                     invokeRestart <- base::invokeRestart
[17:28:20.824]                     is.null <- base::is.null
[17:28:20.824]                     muffled <- FALSE
[17:28:20.824]                     if (inherits(cond, "message")) {
[17:28:20.824]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.824]                       if (muffled) 
[17:28:20.824]                         invokeRestart("muffleMessage")
[17:28:20.824]                     }
[17:28:20.824]                     else if (inherits(cond, "warning")) {
[17:28:20.824]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.824]                       if (muffled) 
[17:28:20.824]                         invokeRestart("muffleWarning")
[17:28:20.824]                     }
[17:28:20.824]                     else if (inherits(cond, "condition")) {
[17:28:20.824]                       if (!is.null(pattern)) {
[17:28:20.824]                         computeRestarts <- base::computeRestarts
[17:28:20.824]                         grepl <- base::grepl
[17:28:20.824]                         restarts <- computeRestarts(cond)
[17:28:20.824]                         for (restart in restarts) {
[17:28:20.824]                           name <- restart$name
[17:28:20.824]                           if (is.null(name)) 
[17:28:20.824]                             next
[17:28:20.824]                           if (!grepl(pattern, name)) 
[17:28:20.824]                             next
[17:28:20.824]                           invokeRestart(restart)
[17:28:20.824]                           muffled <- TRUE
[17:28:20.824]                           break
[17:28:20.824]                         }
[17:28:20.824]                       }
[17:28:20.824]                     }
[17:28:20.824]                     invisible(muffled)
[17:28:20.824]                   }
[17:28:20.824]                   muffleCondition(cond)
[17:28:20.824]                 })
[17:28:20.824]             }))
[17:28:20.824]             future::FutureResult(value = ...future.value$value, 
[17:28:20.824]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.824]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.824]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.824]                     ...future.globalenv.names))
[17:28:20.824]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.824]         }, condition = base::local({
[17:28:20.824]             c <- base::c
[17:28:20.824]             inherits <- base::inherits
[17:28:20.824]             invokeRestart <- base::invokeRestart
[17:28:20.824]             length <- base::length
[17:28:20.824]             list <- base::list
[17:28:20.824]             seq.int <- base::seq.int
[17:28:20.824]             signalCondition <- base::signalCondition
[17:28:20.824]             sys.calls <- base::sys.calls
[17:28:20.824]             `[[` <- base::`[[`
[17:28:20.824]             `+` <- base::`+`
[17:28:20.824]             `<<-` <- base::`<<-`
[17:28:20.824]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.824]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.824]                   3L)]
[17:28:20.824]             }
[17:28:20.824]             function(cond) {
[17:28:20.824]                 is_error <- inherits(cond, "error")
[17:28:20.824]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.824]                   NULL)
[17:28:20.824]                 if (is_error) {
[17:28:20.824]                   sessionInformation <- function() {
[17:28:20.824]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.824]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.824]                       search = base::search(), system = base::Sys.info())
[17:28:20.824]                   }
[17:28:20.824]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.824]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.824]                     cond$call), session = sessionInformation(), 
[17:28:20.824]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.824]                   signalCondition(cond)
[17:28:20.824]                 }
[17:28:20.824]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.824]                 "immediateCondition"))) {
[17:28:20.824]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.824]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.824]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.824]                   if (TRUE && !signal) {
[17:28:20.824]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.824]                     {
[17:28:20.824]                       inherits <- base::inherits
[17:28:20.824]                       invokeRestart <- base::invokeRestart
[17:28:20.824]                       is.null <- base::is.null
[17:28:20.824]                       muffled <- FALSE
[17:28:20.824]                       if (inherits(cond, "message")) {
[17:28:20.824]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.824]                         if (muffled) 
[17:28:20.824]                           invokeRestart("muffleMessage")
[17:28:20.824]                       }
[17:28:20.824]                       else if (inherits(cond, "warning")) {
[17:28:20.824]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.824]                         if (muffled) 
[17:28:20.824]                           invokeRestart("muffleWarning")
[17:28:20.824]                       }
[17:28:20.824]                       else if (inherits(cond, "condition")) {
[17:28:20.824]                         if (!is.null(pattern)) {
[17:28:20.824]                           computeRestarts <- base::computeRestarts
[17:28:20.824]                           grepl <- base::grepl
[17:28:20.824]                           restarts <- computeRestarts(cond)
[17:28:20.824]                           for (restart in restarts) {
[17:28:20.824]                             name <- restart$name
[17:28:20.824]                             if (is.null(name)) 
[17:28:20.824]                               next
[17:28:20.824]                             if (!grepl(pattern, name)) 
[17:28:20.824]                               next
[17:28:20.824]                             invokeRestart(restart)
[17:28:20.824]                             muffled <- TRUE
[17:28:20.824]                             break
[17:28:20.824]                           }
[17:28:20.824]                         }
[17:28:20.824]                       }
[17:28:20.824]                       invisible(muffled)
[17:28:20.824]                     }
[17:28:20.824]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.824]                   }
[17:28:20.824]                 }
[17:28:20.824]                 else {
[17:28:20.824]                   if (TRUE) {
[17:28:20.824]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.824]                     {
[17:28:20.824]                       inherits <- base::inherits
[17:28:20.824]                       invokeRestart <- base::invokeRestart
[17:28:20.824]                       is.null <- base::is.null
[17:28:20.824]                       muffled <- FALSE
[17:28:20.824]                       if (inherits(cond, "message")) {
[17:28:20.824]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.824]                         if (muffled) 
[17:28:20.824]                           invokeRestart("muffleMessage")
[17:28:20.824]                       }
[17:28:20.824]                       else if (inherits(cond, "warning")) {
[17:28:20.824]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.824]                         if (muffled) 
[17:28:20.824]                           invokeRestart("muffleWarning")
[17:28:20.824]                       }
[17:28:20.824]                       else if (inherits(cond, "condition")) {
[17:28:20.824]                         if (!is.null(pattern)) {
[17:28:20.824]                           computeRestarts <- base::computeRestarts
[17:28:20.824]                           grepl <- base::grepl
[17:28:20.824]                           restarts <- computeRestarts(cond)
[17:28:20.824]                           for (restart in restarts) {
[17:28:20.824]                             name <- restart$name
[17:28:20.824]                             if (is.null(name)) 
[17:28:20.824]                               next
[17:28:20.824]                             if (!grepl(pattern, name)) 
[17:28:20.824]                               next
[17:28:20.824]                             invokeRestart(restart)
[17:28:20.824]                             muffled <- TRUE
[17:28:20.824]                             break
[17:28:20.824]                           }
[17:28:20.824]                         }
[17:28:20.824]                       }
[17:28:20.824]                       invisible(muffled)
[17:28:20.824]                     }
[17:28:20.824]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.824]                   }
[17:28:20.824]                 }
[17:28:20.824]             }
[17:28:20.824]         }))
[17:28:20.824]     }, error = function(ex) {
[17:28:20.824]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.824]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.824]                 ...future.rng), started = ...future.startTime, 
[17:28:20.824]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.824]             version = "1.8"), class = "FutureResult")
[17:28:20.824]     }, finally = {
[17:28:20.824]         if (!identical(...future.workdir, getwd())) 
[17:28:20.824]             setwd(...future.workdir)
[17:28:20.824]         {
[17:28:20.824]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.824]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.824]             }
[17:28:20.824]             base::options(...future.oldOptions)
[17:28:20.824]             if (.Platform$OS.type == "windows") {
[17:28:20.824]                 old_names <- names(...future.oldEnvVars)
[17:28:20.824]                 envs <- base::Sys.getenv()
[17:28:20.824]                 names <- names(envs)
[17:28:20.824]                 common <- intersect(names, old_names)
[17:28:20.824]                 added <- setdiff(names, old_names)
[17:28:20.824]                 removed <- setdiff(old_names, names)
[17:28:20.824]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.824]                   envs[common]]
[17:28:20.824]                 NAMES <- toupper(changed)
[17:28:20.824]                 args <- list()
[17:28:20.824]                 for (kk in seq_along(NAMES)) {
[17:28:20.824]                   name <- changed[[kk]]
[17:28:20.824]                   NAME <- NAMES[[kk]]
[17:28:20.824]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.824]                     next
[17:28:20.824]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.824]                 }
[17:28:20.824]                 NAMES <- toupper(added)
[17:28:20.824]                 for (kk in seq_along(NAMES)) {
[17:28:20.824]                   name <- added[[kk]]
[17:28:20.824]                   NAME <- NAMES[[kk]]
[17:28:20.824]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.824]                     next
[17:28:20.824]                   args[[name]] <- ""
[17:28:20.824]                 }
[17:28:20.824]                 NAMES <- toupper(removed)
[17:28:20.824]                 for (kk in seq_along(NAMES)) {
[17:28:20.824]                   name <- removed[[kk]]
[17:28:20.824]                   NAME <- NAMES[[kk]]
[17:28:20.824]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.824]                     next
[17:28:20.824]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.824]                 }
[17:28:20.824]                 if (length(args) > 0) 
[17:28:20.824]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.824]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.824]             }
[17:28:20.824]             else {
[17:28:20.824]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.824]             }
[17:28:20.824]             {
[17:28:20.824]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.824]                   0L) {
[17:28:20.824]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.824]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.824]                   base::options(opts)
[17:28:20.824]                 }
[17:28:20.824]                 {
[17:28:20.824]                   {
[17:28:20.824]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.824]                     NULL
[17:28:20.824]                   }
[17:28:20.824]                   options(future.plan = NULL)
[17:28:20.824]                   if (is.na(NA_character_)) 
[17:28:20.824]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.824]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.824]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.824]                     .init = FALSE)
[17:28:20.824]                 }
[17:28:20.824]             }
[17:28:20.824]         }
[17:28:20.824]     })
[17:28:20.824]     if (TRUE) {
[17:28:20.824]         base::sink(type = "output", split = FALSE)
[17:28:20.824]         if (TRUE) {
[17:28:20.824]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.824]         }
[17:28:20.824]         else {
[17:28:20.824]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.824]         }
[17:28:20.824]         base::close(...future.stdout)
[17:28:20.824]         ...future.stdout <- NULL
[17:28:20.824]     }
[17:28:20.824]     ...future.result$conditions <- ...future.conditions
[17:28:20.824]     ...future.result$finished <- base::Sys.time()
[17:28:20.824]     ...future.result
[17:28:20.824] }
[17:28:20.829] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.829] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.829] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.830] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.830] MultisessionFuture started
[17:28:20.830] - Launch lazy future ... done
[17:28:20.831] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-23576'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x00000266775329d0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:28:20.844] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.845] - Validating connection of MultisessionFuture
[17:28:20.845] - received message: FutureResult
[17:28:20.845] - Received FutureResult
[17:28:20.845] - Erased future from FutureRegistry
[17:28:20.845] result() for ClusterFuture ...
[17:28:20.846] - result already collected: FutureResult
[17:28:20.846] result() for ClusterFuture ... done
[17:28:20.846] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.846] getGlobalsAndPackages() ...
[17:28:20.846] Searching for globals...
[17:28:20.847] - globals found: [3] '{', 'sample', 'x'
[17:28:20.848] Searching for globals ... DONE
[17:28:20.848] Resolving globals: FALSE
[17:28:20.848] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.849] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.849] - globals: [1] 'x'
[17:28:20.849] 
[17:28:20.849] getGlobalsAndPackages() ... DONE
[17:28:20.850] run() for 'Future' ...
[17:28:20.850] - state: 'created'
[17:28:20.850] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.863] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.863] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.864]   - Field: 'node'
[17:28:20.864]   - Field: 'label'
[17:28:20.864]   - Field: 'local'
[17:28:20.864]   - Field: 'owner'
[17:28:20.864]   - Field: 'envir'
[17:28:20.865]   - Field: 'workers'
[17:28:20.865]   - Field: 'packages'
[17:28:20.865]   - Field: 'gc'
[17:28:20.865]   - Field: 'conditions'
[17:28:20.865]   - Field: 'persistent'
[17:28:20.865]   - Field: 'expr'
[17:28:20.866]   - Field: 'uuid'
[17:28:20.866]   - Field: 'seed'
[17:28:20.866]   - Field: 'version'
[17:28:20.866]   - Field: 'result'
[17:28:20.866]   - Field: 'asynchronous'
[17:28:20.866]   - Field: 'calls'
[17:28:20.867]   - Field: 'globals'
[17:28:20.867]   - Field: 'stdout'
[17:28:20.867]   - Field: 'earlySignal'
[17:28:20.867]   - Field: 'lazy'
[17:28:20.867]   - Field: 'state'
[17:28:20.868] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.868] - Launch lazy future ...
[17:28:20.868] Packages needed by the future expression (n = 0): <none>
[17:28:20.868] Packages needed by future strategies (n = 0): <none>
[17:28:20.869] {
[17:28:20.869]     {
[17:28:20.869]         {
[17:28:20.869]             ...future.startTime <- base::Sys.time()
[17:28:20.869]             {
[17:28:20.869]                 {
[17:28:20.869]                   {
[17:28:20.869]                     {
[17:28:20.869]                       base::local({
[17:28:20.869]                         has_future <- base::requireNamespace("future", 
[17:28:20.869]                           quietly = TRUE)
[17:28:20.869]                         if (has_future) {
[17:28:20.869]                           ns <- base::getNamespace("future")
[17:28:20.869]                           version <- ns[[".package"]][["version"]]
[17:28:20.869]                           if (is.null(version)) 
[17:28:20.869]                             version <- utils::packageVersion("future")
[17:28:20.869]                         }
[17:28:20.869]                         else {
[17:28:20.869]                           version <- NULL
[17:28:20.869]                         }
[17:28:20.869]                         if (!has_future || version < "1.8.0") {
[17:28:20.869]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.869]                             "", base::R.version$version.string), 
[17:28:20.869]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.869]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.869]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.869]                               "release", "version")], collapse = " "), 
[17:28:20.869]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.869]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.869]                             info)
[17:28:20.869]                           info <- base::paste(info, collapse = "; ")
[17:28:20.869]                           if (!has_future) {
[17:28:20.869]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.869]                               info)
[17:28:20.869]                           }
[17:28:20.869]                           else {
[17:28:20.869]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.869]                               info, version)
[17:28:20.869]                           }
[17:28:20.869]                           base::stop(msg)
[17:28:20.869]                         }
[17:28:20.869]                       })
[17:28:20.869]                     }
[17:28:20.869]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.869]                     base::options(mc.cores = 1L)
[17:28:20.869]                   }
[17:28:20.869]                   ...future.strategy.old <- future::plan("list")
[17:28:20.869]                   options(future.plan = NULL)
[17:28:20.869]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.869]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.869]                 }
[17:28:20.869]                 ...future.workdir <- getwd()
[17:28:20.869]             }
[17:28:20.869]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.869]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.869]         }
[17:28:20.869]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.869]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.869]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.869]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.869]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.869]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.869]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.869]             base::names(...future.oldOptions))
[17:28:20.869]     }
[17:28:20.869]     if (FALSE) {
[17:28:20.869]     }
[17:28:20.869]     else {
[17:28:20.869]         if (TRUE) {
[17:28:20.869]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.869]                 open = "w")
[17:28:20.869]         }
[17:28:20.869]         else {
[17:28:20.869]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.869]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.869]         }
[17:28:20.869]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.869]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.869]             base::sink(type = "output", split = FALSE)
[17:28:20.869]             base::close(...future.stdout)
[17:28:20.869]         }, add = TRUE)
[17:28:20.869]     }
[17:28:20.869]     ...future.frame <- base::sys.nframe()
[17:28:20.869]     ...future.conditions <- base::list()
[17:28:20.869]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.869]     if (FALSE) {
[17:28:20.869]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.869]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.869]     }
[17:28:20.869]     ...future.result <- base::tryCatch({
[17:28:20.869]         base::withCallingHandlers({
[17:28:20.869]             ...future.value <- base::withVisible(base::local({
[17:28:20.869]                 ...future.makeSendCondition <- base::local({
[17:28:20.869]                   sendCondition <- NULL
[17:28:20.869]                   function(frame = 1L) {
[17:28:20.869]                     if (is.function(sendCondition)) 
[17:28:20.869]                       return(sendCondition)
[17:28:20.869]                     ns <- getNamespace("parallel")
[17:28:20.869]                     if (exists("sendData", mode = "function", 
[17:28:20.869]                       envir = ns)) {
[17:28:20.869]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.869]                         envir = ns)
[17:28:20.869]                       envir <- sys.frame(frame)
[17:28:20.869]                       master <- NULL
[17:28:20.869]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.869]                         !identical(envir, emptyenv())) {
[17:28:20.869]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.869]                           inherits = FALSE)) {
[17:28:20.869]                           master <- get("master", mode = "list", 
[17:28:20.869]                             envir = envir, inherits = FALSE)
[17:28:20.869]                           if (inherits(master, c("SOCKnode", 
[17:28:20.869]                             "SOCK0node"))) {
[17:28:20.869]                             sendCondition <<- function(cond) {
[17:28:20.869]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.869]                                 success = TRUE)
[17:28:20.869]                               parallel_sendData(master, data)
[17:28:20.869]                             }
[17:28:20.869]                             return(sendCondition)
[17:28:20.869]                           }
[17:28:20.869]                         }
[17:28:20.869]                         frame <- frame + 1L
[17:28:20.869]                         envir <- sys.frame(frame)
[17:28:20.869]                       }
[17:28:20.869]                     }
[17:28:20.869]                     sendCondition <<- function(cond) NULL
[17:28:20.869]                   }
[17:28:20.869]                 })
[17:28:20.869]                 withCallingHandlers({
[17:28:20.869]                   {
[17:28:20.869]                     sample(x, size = 1L)
[17:28:20.869]                   }
[17:28:20.869]                 }, immediateCondition = function(cond) {
[17:28:20.869]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.869]                   sendCondition(cond)
[17:28:20.869]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.869]                   {
[17:28:20.869]                     inherits <- base::inherits
[17:28:20.869]                     invokeRestart <- base::invokeRestart
[17:28:20.869]                     is.null <- base::is.null
[17:28:20.869]                     muffled <- FALSE
[17:28:20.869]                     if (inherits(cond, "message")) {
[17:28:20.869]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.869]                       if (muffled) 
[17:28:20.869]                         invokeRestart("muffleMessage")
[17:28:20.869]                     }
[17:28:20.869]                     else if (inherits(cond, "warning")) {
[17:28:20.869]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.869]                       if (muffled) 
[17:28:20.869]                         invokeRestart("muffleWarning")
[17:28:20.869]                     }
[17:28:20.869]                     else if (inherits(cond, "condition")) {
[17:28:20.869]                       if (!is.null(pattern)) {
[17:28:20.869]                         computeRestarts <- base::computeRestarts
[17:28:20.869]                         grepl <- base::grepl
[17:28:20.869]                         restarts <- computeRestarts(cond)
[17:28:20.869]                         for (restart in restarts) {
[17:28:20.869]                           name <- restart$name
[17:28:20.869]                           if (is.null(name)) 
[17:28:20.869]                             next
[17:28:20.869]                           if (!grepl(pattern, name)) 
[17:28:20.869]                             next
[17:28:20.869]                           invokeRestart(restart)
[17:28:20.869]                           muffled <- TRUE
[17:28:20.869]                           break
[17:28:20.869]                         }
[17:28:20.869]                       }
[17:28:20.869]                     }
[17:28:20.869]                     invisible(muffled)
[17:28:20.869]                   }
[17:28:20.869]                   muffleCondition(cond)
[17:28:20.869]                 })
[17:28:20.869]             }))
[17:28:20.869]             future::FutureResult(value = ...future.value$value, 
[17:28:20.869]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.869]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.869]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.869]                     ...future.globalenv.names))
[17:28:20.869]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.869]         }, condition = base::local({
[17:28:20.869]             c <- base::c
[17:28:20.869]             inherits <- base::inherits
[17:28:20.869]             invokeRestart <- base::invokeRestart
[17:28:20.869]             length <- base::length
[17:28:20.869]             list <- base::list
[17:28:20.869]             seq.int <- base::seq.int
[17:28:20.869]             signalCondition <- base::signalCondition
[17:28:20.869]             sys.calls <- base::sys.calls
[17:28:20.869]             `[[` <- base::`[[`
[17:28:20.869]             `+` <- base::`+`
[17:28:20.869]             `<<-` <- base::`<<-`
[17:28:20.869]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.869]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.869]                   3L)]
[17:28:20.869]             }
[17:28:20.869]             function(cond) {
[17:28:20.869]                 is_error <- inherits(cond, "error")
[17:28:20.869]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.869]                   NULL)
[17:28:20.869]                 if (is_error) {
[17:28:20.869]                   sessionInformation <- function() {
[17:28:20.869]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.869]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.869]                       search = base::search(), system = base::Sys.info())
[17:28:20.869]                   }
[17:28:20.869]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.869]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.869]                     cond$call), session = sessionInformation(), 
[17:28:20.869]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.869]                   signalCondition(cond)
[17:28:20.869]                 }
[17:28:20.869]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.869]                 "immediateCondition"))) {
[17:28:20.869]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.869]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.869]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.869]                   if (TRUE && !signal) {
[17:28:20.869]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.869]                     {
[17:28:20.869]                       inherits <- base::inherits
[17:28:20.869]                       invokeRestart <- base::invokeRestart
[17:28:20.869]                       is.null <- base::is.null
[17:28:20.869]                       muffled <- FALSE
[17:28:20.869]                       if (inherits(cond, "message")) {
[17:28:20.869]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.869]                         if (muffled) 
[17:28:20.869]                           invokeRestart("muffleMessage")
[17:28:20.869]                       }
[17:28:20.869]                       else if (inherits(cond, "warning")) {
[17:28:20.869]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.869]                         if (muffled) 
[17:28:20.869]                           invokeRestart("muffleWarning")
[17:28:20.869]                       }
[17:28:20.869]                       else if (inherits(cond, "condition")) {
[17:28:20.869]                         if (!is.null(pattern)) {
[17:28:20.869]                           computeRestarts <- base::computeRestarts
[17:28:20.869]                           grepl <- base::grepl
[17:28:20.869]                           restarts <- computeRestarts(cond)
[17:28:20.869]                           for (restart in restarts) {
[17:28:20.869]                             name <- restart$name
[17:28:20.869]                             if (is.null(name)) 
[17:28:20.869]                               next
[17:28:20.869]                             if (!grepl(pattern, name)) 
[17:28:20.869]                               next
[17:28:20.869]                             invokeRestart(restart)
[17:28:20.869]                             muffled <- TRUE
[17:28:20.869]                             break
[17:28:20.869]                           }
[17:28:20.869]                         }
[17:28:20.869]                       }
[17:28:20.869]                       invisible(muffled)
[17:28:20.869]                     }
[17:28:20.869]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.869]                   }
[17:28:20.869]                 }
[17:28:20.869]                 else {
[17:28:20.869]                   if (TRUE) {
[17:28:20.869]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.869]                     {
[17:28:20.869]                       inherits <- base::inherits
[17:28:20.869]                       invokeRestart <- base::invokeRestart
[17:28:20.869]                       is.null <- base::is.null
[17:28:20.869]                       muffled <- FALSE
[17:28:20.869]                       if (inherits(cond, "message")) {
[17:28:20.869]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.869]                         if (muffled) 
[17:28:20.869]                           invokeRestart("muffleMessage")
[17:28:20.869]                       }
[17:28:20.869]                       else if (inherits(cond, "warning")) {
[17:28:20.869]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.869]                         if (muffled) 
[17:28:20.869]                           invokeRestart("muffleWarning")
[17:28:20.869]                       }
[17:28:20.869]                       else if (inherits(cond, "condition")) {
[17:28:20.869]                         if (!is.null(pattern)) {
[17:28:20.869]                           computeRestarts <- base::computeRestarts
[17:28:20.869]                           grepl <- base::grepl
[17:28:20.869]                           restarts <- computeRestarts(cond)
[17:28:20.869]                           for (restart in restarts) {
[17:28:20.869]                             name <- restart$name
[17:28:20.869]                             if (is.null(name)) 
[17:28:20.869]                               next
[17:28:20.869]                             if (!grepl(pattern, name)) 
[17:28:20.869]                               next
[17:28:20.869]                             invokeRestart(restart)
[17:28:20.869]                             muffled <- TRUE
[17:28:20.869]                             break
[17:28:20.869]                           }
[17:28:20.869]                         }
[17:28:20.869]                       }
[17:28:20.869]                       invisible(muffled)
[17:28:20.869]                     }
[17:28:20.869]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.869]                   }
[17:28:20.869]                 }
[17:28:20.869]             }
[17:28:20.869]         }))
[17:28:20.869]     }, error = function(ex) {
[17:28:20.869]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.869]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.869]                 ...future.rng), started = ...future.startTime, 
[17:28:20.869]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.869]             version = "1.8"), class = "FutureResult")
[17:28:20.869]     }, finally = {
[17:28:20.869]         if (!identical(...future.workdir, getwd())) 
[17:28:20.869]             setwd(...future.workdir)
[17:28:20.869]         {
[17:28:20.869]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.869]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.869]             }
[17:28:20.869]             base::options(...future.oldOptions)
[17:28:20.869]             if (.Platform$OS.type == "windows") {
[17:28:20.869]                 old_names <- names(...future.oldEnvVars)
[17:28:20.869]                 envs <- base::Sys.getenv()
[17:28:20.869]                 names <- names(envs)
[17:28:20.869]                 common <- intersect(names, old_names)
[17:28:20.869]                 added <- setdiff(names, old_names)
[17:28:20.869]                 removed <- setdiff(old_names, names)
[17:28:20.869]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.869]                   envs[common]]
[17:28:20.869]                 NAMES <- toupper(changed)
[17:28:20.869]                 args <- list()
[17:28:20.869]                 for (kk in seq_along(NAMES)) {
[17:28:20.869]                   name <- changed[[kk]]
[17:28:20.869]                   NAME <- NAMES[[kk]]
[17:28:20.869]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.869]                     next
[17:28:20.869]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.869]                 }
[17:28:20.869]                 NAMES <- toupper(added)
[17:28:20.869]                 for (kk in seq_along(NAMES)) {
[17:28:20.869]                   name <- added[[kk]]
[17:28:20.869]                   NAME <- NAMES[[kk]]
[17:28:20.869]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.869]                     next
[17:28:20.869]                   args[[name]] <- ""
[17:28:20.869]                 }
[17:28:20.869]                 NAMES <- toupper(removed)
[17:28:20.869]                 for (kk in seq_along(NAMES)) {
[17:28:20.869]                   name <- removed[[kk]]
[17:28:20.869]                   NAME <- NAMES[[kk]]
[17:28:20.869]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.869]                     next
[17:28:20.869]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.869]                 }
[17:28:20.869]                 if (length(args) > 0) 
[17:28:20.869]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.869]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.869]             }
[17:28:20.869]             else {
[17:28:20.869]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.869]             }
[17:28:20.869]             {
[17:28:20.869]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.869]                   0L) {
[17:28:20.869]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.869]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.869]                   base::options(opts)
[17:28:20.869]                 }
[17:28:20.869]                 {
[17:28:20.869]                   {
[17:28:20.869]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.869]                     NULL
[17:28:20.869]                   }
[17:28:20.869]                   options(future.plan = NULL)
[17:28:20.869]                   if (is.na(NA_character_)) 
[17:28:20.869]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.869]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.869]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.869]                     .init = FALSE)
[17:28:20.869]                 }
[17:28:20.869]             }
[17:28:20.869]         }
[17:28:20.869]     })
[17:28:20.869]     if (TRUE) {
[17:28:20.869]         base::sink(type = "output", split = FALSE)
[17:28:20.869]         if (TRUE) {
[17:28:20.869]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.869]         }
[17:28:20.869]         else {
[17:28:20.869]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.869]         }
[17:28:20.869]         base::close(...future.stdout)
[17:28:20.869]         ...future.stdout <- NULL
[17:28:20.869]     }
[17:28:20.869]     ...future.result$conditions <- ...future.conditions
[17:28:20.869]     ...future.result$finished <- base::Sys.time()
[17:28:20.869]     ...future.result
[17:28:20.869] }
[17:28:20.874] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.874] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.874] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.875] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.875] MultisessionFuture started
[17:28:20.875] - Launch lazy future ... done
[17:28:20.876] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-373122'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x00000266775329d0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:28:20.889] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.890] - Validating connection of MultisessionFuture
[17:28:20.890] - received message: FutureResult
[17:28:20.890] - Received FutureResult
[17:28:20.890] - Erased future from FutureRegistry
[17:28:20.890] result() for ClusterFuture ...
[17:28:20.891] - result already collected: FutureResult
[17:28:20.891] result() for ClusterFuture ... done
[17:28:20.891] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.891] resolve() on list ...
[17:28:20.891]  recursive: 0
[17:28:20.891]  length: 4
[17:28:20.892] 
[17:28:20.892] Future #1
[17:28:20.892] result() for ClusterFuture ...
[17:28:20.892] - result already collected: FutureResult
[17:28:20.892] result() for ClusterFuture ... done
[17:28:20.892] result() for ClusterFuture ...
[17:28:20.893] - result already collected: FutureResult
[17:28:20.893] result() for ClusterFuture ... done
[17:28:20.893] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:28:20.893] - nx: 4
[17:28:20.893] - relay: TRUE
[17:28:20.894] - stdout: TRUE
[17:28:20.894] - signal: TRUE
[17:28:20.894] - resignal: FALSE
[17:28:20.894] - force: TRUE
[17:28:20.894] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:20.894] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:20.894]  - until=1
[17:28:20.895]  - relaying element #1
[17:28:20.895] result() for ClusterFuture ...
[17:28:20.895] - result already collected: FutureResult
[17:28:20.895] result() for ClusterFuture ... done
[17:28:20.895] result() for ClusterFuture ...
[17:28:20.895] - result already collected: FutureResult
[17:28:20.896] result() for ClusterFuture ... done
[17:28:20.896] signalConditions() ...
[17:28:20.896]  - include = 'immediateCondition'
[17:28:20.896]  - exclude = 
[17:28:20.896]  - resignal = FALSE
[17:28:20.896]  - Number of conditions: 1
[17:28:20.897] signalConditions() ... done
[17:28:20.897] result() for ClusterFuture ...
[17:28:20.897] - result already collected: FutureResult
[17:28:20.897] result() for ClusterFuture ... done
[17:28:20.897] signalConditions() ...
[17:28:20.897]  - include = 'immediateCondition'
[17:28:20.897]  - exclude = 
[17:28:20.898]  - resignal = FALSE
[17:28:20.898]  - Number of conditions: 1
[17:28:20.898] signalConditions() ... done
[17:28:20.898] result() for ClusterFuture ...
[17:28:20.898] - result already collected: FutureResult
[17:28:20.898] result() for ClusterFuture ... done
[17:28:20.899] signalConditions() ...
[17:28:20.899]  - include = 'condition'
[17:28:20.899]  - exclude = 'immediateCondition'
[17:28:20.899]  - resignal = TRUE
[17:28:20.899]  - Number of conditions: 1
[17:28:20.899]  - Condition #1: 'RngFutureError', 'FutureError', 'error', 'RngFutureCondition', 'FutureCondition', 'condition'
[17:28:20.900] signalConditions() ... done
[17:28:20.900] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:20.900] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:20.900] signalConditionsASAP(MultisessionFuture, pos=1) ... done
<RngFutureError: UNRELIABLE VALUE: Future ('fsample_1-316434') 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: d0e0b138-e86a-be5a-c460-329f08a8ab87


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

DEBUG: END TROUBLESHOOTING HELP
[17:28:20.901] getGlobalsAndPackages() ...
[17:28:20.901] Searching for globals...
[17:28:20.903] - globals found: [3] '{', 'sample', 'x'
[17:28:20.903] Searching for globals ... DONE
[17:28:20.903] Resolving globals: FALSE
[17:28:20.903] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.904] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.904] - globals: [1] 'x'
[17:28:20.904] 
[17:28:20.904] getGlobalsAndPackages() ... DONE
[17:28:20.905] run() for 'Future' ...
[17:28:20.905] - state: 'created'
[17:28:20.905] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.918] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.919] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.919]   - Field: 'node'
[17:28:20.919]   - Field: 'label'
[17:28:20.919]   - Field: 'local'
[17:28:20.919]   - Field: 'owner'
[17:28:20.920]   - Field: 'envir'
[17:28:20.920]   - Field: 'workers'
[17:28:20.920]   - Field: 'packages'
[17:28:20.920]   - Field: 'gc'
[17:28:20.920]   - Field: 'conditions'
[17:28:20.921]   - Field: 'persistent'
[17:28:20.921]   - Field: 'expr'
[17:28:20.921]   - Field: 'uuid'
[17:28:20.921]   - Field: 'seed'
[17:28:20.921]   - Field: 'version'
[17:28:20.921]   - Field: 'result'
[17:28:20.922]   - Field: 'asynchronous'
[17:28:20.922]   - Field: 'calls'
[17:28:20.922]   - Field: 'globals'
[17:28:20.922]   - Field: 'stdout'
[17:28:20.922]   - Field: 'earlySignal'
[17:28:20.922]   - Field: 'lazy'
[17:28:20.923]   - Field: 'state'
[17:28:20.923] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.923] - Launch lazy future ...
[17:28:20.923] Packages needed by the future expression (n = 0): <none>
[17:28:20.923] Packages needed by future strategies (n = 0): <none>
[17:28:20.924] {
[17:28:20.924]     {
[17:28:20.924]         {
[17:28:20.924]             ...future.startTime <- base::Sys.time()
[17:28:20.924]             {
[17:28:20.924]                 {
[17:28:20.924]                   {
[17:28:20.924]                     {
[17:28:20.924]                       base::local({
[17:28:20.924]                         has_future <- base::requireNamespace("future", 
[17:28:20.924]                           quietly = TRUE)
[17:28:20.924]                         if (has_future) {
[17:28:20.924]                           ns <- base::getNamespace("future")
[17:28:20.924]                           version <- ns[[".package"]][["version"]]
[17:28:20.924]                           if (is.null(version)) 
[17:28:20.924]                             version <- utils::packageVersion("future")
[17:28:20.924]                         }
[17:28:20.924]                         else {
[17:28:20.924]                           version <- NULL
[17:28:20.924]                         }
[17:28:20.924]                         if (!has_future || version < "1.8.0") {
[17:28:20.924]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.924]                             "", base::R.version$version.string), 
[17:28:20.924]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.924]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.924]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.924]                               "release", "version")], collapse = " "), 
[17:28:20.924]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.924]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.924]                             info)
[17:28:20.924]                           info <- base::paste(info, collapse = "; ")
[17:28:20.924]                           if (!has_future) {
[17:28:20.924]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.924]                               info)
[17:28:20.924]                           }
[17:28:20.924]                           else {
[17:28:20.924]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.924]                               info, version)
[17:28:20.924]                           }
[17:28:20.924]                           base::stop(msg)
[17:28:20.924]                         }
[17:28:20.924]                       })
[17:28:20.924]                     }
[17:28:20.924]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.924]                     base::options(mc.cores = 1L)
[17:28:20.924]                   }
[17:28:20.924]                   ...future.strategy.old <- future::plan("list")
[17:28:20.924]                   options(future.plan = NULL)
[17:28:20.924]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.924]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.924]                 }
[17:28:20.924]                 ...future.workdir <- getwd()
[17:28:20.924]             }
[17:28:20.924]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.924]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.924]         }
[17:28:20.924]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.924]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.924]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.924]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.924]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.924]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.924]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.924]             base::names(...future.oldOptions))
[17:28:20.924]     }
[17:28:20.924]     if (FALSE) {
[17:28:20.924]     }
[17:28:20.924]     else {
[17:28:20.924]         if (TRUE) {
[17:28:20.924]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.924]                 open = "w")
[17:28:20.924]         }
[17:28:20.924]         else {
[17:28:20.924]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.924]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.924]         }
[17:28:20.924]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.924]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.924]             base::sink(type = "output", split = FALSE)
[17:28:20.924]             base::close(...future.stdout)
[17:28:20.924]         }, add = TRUE)
[17:28:20.924]     }
[17:28:20.924]     ...future.frame <- base::sys.nframe()
[17:28:20.924]     ...future.conditions <- base::list()
[17:28:20.924]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.924]     if (FALSE) {
[17:28:20.924]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.924]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.924]     }
[17:28:20.924]     ...future.result <- base::tryCatch({
[17:28:20.924]         base::withCallingHandlers({
[17:28:20.924]             ...future.value <- base::withVisible(base::local({
[17:28:20.924]                 ...future.makeSendCondition <- base::local({
[17:28:20.924]                   sendCondition <- NULL
[17:28:20.924]                   function(frame = 1L) {
[17:28:20.924]                     if (is.function(sendCondition)) 
[17:28:20.924]                       return(sendCondition)
[17:28:20.924]                     ns <- getNamespace("parallel")
[17:28:20.924]                     if (exists("sendData", mode = "function", 
[17:28:20.924]                       envir = ns)) {
[17:28:20.924]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.924]                         envir = ns)
[17:28:20.924]                       envir <- sys.frame(frame)
[17:28:20.924]                       master <- NULL
[17:28:20.924]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.924]                         !identical(envir, emptyenv())) {
[17:28:20.924]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.924]                           inherits = FALSE)) {
[17:28:20.924]                           master <- get("master", mode = "list", 
[17:28:20.924]                             envir = envir, inherits = FALSE)
[17:28:20.924]                           if (inherits(master, c("SOCKnode", 
[17:28:20.924]                             "SOCK0node"))) {
[17:28:20.924]                             sendCondition <<- function(cond) {
[17:28:20.924]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.924]                                 success = TRUE)
[17:28:20.924]                               parallel_sendData(master, data)
[17:28:20.924]                             }
[17:28:20.924]                             return(sendCondition)
[17:28:20.924]                           }
[17:28:20.924]                         }
[17:28:20.924]                         frame <- frame + 1L
[17:28:20.924]                         envir <- sys.frame(frame)
[17:28:20.924]                       }
[17:28:20.924]                     }
[17:28:20.924]                     sendCondition <<- function(cond) NULL
[17:28:20.924]                   }
[17:28:20.924]                 })
[17:28:20.924]                 withCallingHandlers({
[17:28:20.924]                   {
[17:28:20.924]                     sample(x, size = 1L)
[17:28:20.924]                   }
[17:28:20.924]                 }, immediateCondition = function(cond) {
[17:28:20.924]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.924]                   sendCondition(cond)
[17:28:20.924]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.924]                   {
[17:28:20.924]                     inherits <- base::inherits
[17:28:20.924]                     invokeRestart <- base::invokeRestart
[17:28:20.924]                     is.null <- base::is.null
[17:28:20.924]                     muffled <- FALSE
[17:28:20.924]                     if (inherits(cond, "message")) {
[17:28:20.924]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.924]                       if (muffled) 
[17:28:20.924]                         invokeRestart("muffleMessage")
[17:28:20.924]                     }
[17:28:20.924]                     else if (inherits(cond, "warning")) {
[17:28:20.924]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.924]                       if (muffled) 
[17:28:20.924]                         invokeRestart("muffleWarning")
[17:28:20.924]                     }
[17:28:20.924]                     else if (inherits(cond, "condition")) {
[17:28:20.924]                       if (!is.null(pattern)) {
[17:28:20.924]                         computeRestarts <- base::computeRestarts
[17:28:20.924]                         grepl <- base::grepl
[17:28:20.924]                         restarts <- computeRestarts(cond)
[17:28:20.924]                         for (restart in restarts) {
[17:28:20.924]                           name <- restart$name
[17:28:20.924]                           if (is.null(name)) 
[17:28:20.924]                             next
[17:28:20.924]                           if (!grepl(pattern, name)) 
[17:28:20.924]                             next
[17:28:20.924]                           invokeRestart(restart)
[17:28:20.924]                           muffled <- TRUE
[17:28:20.924]                           break
[17:28:20.924]                         }
[17:28:20.924]                       }
[17:28:20.924]                     }
[17:28:20.924]                     invisible(muffled)
[17:28:20.924]                   }
[17:28:20.924]                   muffleCondition(cond)
[17:28:20.924]                 })
[17:28:20.924]             }))
[17:28:20.924]             future::FutureResult(value = ...future.value$value, 
[17:28:20.924]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.924]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.924]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.924]                     ...future.globalenv.names))
[17:28:20.924]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.924]         }, condition = base::local({
[17:28:20.924]             c <- base::c
[17:28:20.924]             inherits <- base::inherits
[17:28:20.924]             invokeRestart <- base::invokeRestart
[17:28:20.924]             length <- base::length
[17:28:20.924]             list <- base::list
[17:28:20.924]             seq.int <- base::seq.int
[17:28:20.924]             signalCondition <- base::signalCondition
[17:28:20.924]             sys.calls <- base::sys.calls
[17:28:20.924]             `[[` <- base::`[[`
[17:28:20.924]             `+` <- base::`+`
[17:28:20.924]             `<<-` <- base::`<<-`
[17:28:20.924]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.924]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.924]                   3L)]
[17:28:20.924]             }
[17:28:20.924]             function(cond) {
[17:28:20.924]                 is_error <- inherits(cond, "error")
[17:28:20.924]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.924]                   NULL)
[17:28:20.924]                 if (is_error) {
[17:28:20.924]                   sessionInformation <- function() {
[17:28:20.924]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.924]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.924]                       search = base::search(), system = base::Sys.info())
[17:28:20.924]                   }
[17:28:20.924]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.924]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.924]                     cond$call), session = sessionInformation(), 
[17:28:20.924]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.924]                   signalCondition(cond)
[17:28:20.924]                 }
[17:28:20.924]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.924]                 "immediateCondition"))) {
[17:28:20.924]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.924]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.924]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.924]                   if (TRUE && !signal) {
[17:28:20.924]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.924]                     {
[17:28:20.924]                       inherits <- base::inherits
[17:28:20.924]                       invokeRestart <- base::invokeRestart
[17:28:20.924]                       is.null <- base::is.null
[17:28:20.924]                       muffled <- FALSE
[17:28:20.924]                       if (inherits(cond, "message")) {
[17:28:20.924]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.924]                         if (muffled) 
[17:28:20.924]                           invokeRestart("muffleMessage")
[17:28:20.924]                       }
[17:28:20.924]                       else if (inherits(cond, "warning")) {
[17:28:20.924]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.924]                         if (muffled) 
[17:28:20.924]                           invokeRestart("muffleWarning")
[17:28:20.924]                       }
[17:28:20.924]                       else if (inherits(cond, "condition")) {
[17:28:20.924]                         if (!is.null(pattern)) {
[17:28:20.924]                           computeRestarts <- base::computeRestarts
[17:28:20.924]                           grepl <- base::grepl
[17:28:20.924]                           restarts <- computeRestarts(cond)
[17:28:20.924]                           for (restart in restarts) {
[17:28:20.924]                             name <- restart$name
[17:28:20.924]                             if (is.null(name)) 
[17:28:20.924]                               next
[17:28:20.924]                             if (!grepl(pattern, name)) 
[17:28:20.924]                               next
[17:28:20.924]                             invokeRestart(restart)
[17:28:20.924]                             muffled <- TRUE
[17:28:20.924]                             break
[17:28:20.924]                           }
[17:28:20.924]                         }
[17:28:20.924]                       }
[17:28:20.924]                       invisible(muffled)
[17:28:20.924]                     }
[17:28:20.924]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.924]                   }
[17:28:20.924]                 }
[17:28:20.924]                 else {
[17:28:20.924]                   if (TRUE) {
[17:28:20.924]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.924]                     {
[17:28:20.924]                       inherits <- base::inherits
[17:28:20.924]                       invokeRestart <- base::invokeRestart
[17:28:20.924]                       is.null <- base::is.null
[17:28:20.924]                       muffled <- FALSE
[17:28:20.924]                       if (inherits(cond, "message")) {
[17:28:20.924]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.924]                         if (muffled) 
[17:28:20.924]                           invokeRestart("muffleMessage")
[17:28:20.924]                       }
[17:28:20.924]                       else if (inherits(cond, "warning")) {
[17:28:20.924]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.924]                         if (muffled) 
[17:28:20.924]                           invokeRestart("muffleWarning")
[17:28:20.924]                       }
[17:28:20.924]                       else if (inherits(cond, "condition")) {
[17:28:20.924]                         if (!is.null(pattern)) {
[17:28:20.924]                           computeRestarts <- base::computeRestarts
[17:28:20.924]                           grepl <- base::grepl
[17:28:20.924]                           restarts <- computeRestarts(cond)
[17:28:20.924]                           for (restart in restarts) {
[17:28:20.924]                             name <- restart$name
[17:28:20.924]                             if (is.null(name)) 
[17:28:20.924]                               next
[17:28:20.924]                             if (!grepl(pattern, name)) 
[17:28:20.924]                               next
[17:28:20.924]                             invokeRestart(restart)
[17:28:20.924]                             muffled <- TRUE
[17:28:20.924]                             break
[17:28:20.924]                           }
[17:28:20.924]                         }
[17:28:20.924]                       }
[17:28:20.924]                       invisible(muffled)
[17:28:20.924]                     }
[17:28:20.924]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.924]                   }
[17:28:20.924]                 }
[17:28:20.924]             }
[17:28:20.924]         }))
[17:28:20.924]     }, error = function(ex) {
[17:28:20.924]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.924]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.924]                 ...future.rng), started = ...future.startTime, 
[17:28:20.924]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.924]             version = "1.8"), class = "FutureResult")
[17:28:20.924]     }, finally = {
[17:28:20.924]         if (!identical(...future.workdir, getwd())) 
[17:28:20.924]             setwd(...future.workdir)
[17:28:20.924]         {
[17:28:20.924]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.924]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.924]             }
[17:28:20.924]             base::options(...future.oldOptions)
[17:28:20.924]             if (.Platform$OS.type == "windows") {
[17:28:20.924]                 old_names <- names(...future.oldEnvVars)
[17:28:20.924]                 envs <- base::Sys.getenv()
[17:28:20.924]                 names <- names(envs)
[17:28:20.924]                 common <- intersect(names, old_names)
[17:28:20.924]                 added <- setdiff(names, old_names)
[17:28:20.924]                 removed <- setdiff(old_names, names)
[17:28:20.924]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.924]                   envs[common]]
[17:28:20.924]                 NAMES <- toupper(changed)
[17:28:20.924]                 args <- list()
[17:28:20.924]                 for (kk in seq_along(NAMES)) {
[17:28:20.924]                   name <- changed[[kk]]
[17:28:20.924]                   NAME <- NAMES[[kk]]
[17:28:20.924]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.924]                     next
[17:28:20.924]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.924]                 }
[17:28:20.924]                 NAMES <- toupper(added)
[17:28:20.924]                 for (kk in seq_along(NAMES)) {
[17:28:20.924]                   name <- added[[kk]]
[17:28:20.924]                   NAME <- NAMES[[kk]]
[17:28:20.924]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.924]                     next
[17:28:20.924]                   args[[name]] <- ""
[17:28:20.924]                 }
[17:28:20.924]                 NAMES <- toupper(removed)
[17:28:20.924]                 for (kk in seq_along(NAMES)) {
[17:28:20.924]                   name <- removed[[kk]]
[17:28:20.924]                   NAME <- NAMES[[kk]]
[17:28:20.924]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.924]                     next
[17:28:20.924]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.924]                 }
[17:28:20.924]                 if (length(args) > 0) 
[17:28:20.924]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.924]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.924]             }
[17:28:20.924]             else {
[17:28:20.924]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.924]             }
[17:28:20.924]             {
[17:28:20.924]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.924]                   0L) {
[17:28:20.924]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.924]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.924]                   base::options(opts)
[17:28:20.924]                 }
[17:28:20.924]                 {
[17:28:20.924]                   {
[17:28:20.924]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.924]                     NULL
[17:28:20.924]                   }
[17:28:20.924]                   options(future.plan = NULL)
[17:28:20.924]                   if (is.na(NA_character_)) 
[17:28:20.924]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.924]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.924]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.924]                     .init = FALSE)
[17:28:20.924]                 }
[17:28:20.924]             }
[17:28:20.924]         }
[17:28:20.924]     })
[17:28:20.924]     if (TRUE) {
[17:28:20.924]         base::sink(type = "output", split = FALSE)
[17:28:20.924]         if (TRUE) {
[17:28:20.924]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.924]         }
[17:28:20.924]         else {
[17:28:20.924]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.924]         }
[17:28:20.924]         base::close(...future.stdout)
[17:28:20.924]         ...future.stdout <- NULL
[17:28:20.924]     }
[17:28:20.924]     ...future.result$conditions <- ...future.conditions
[17:28:20.924]     ...future.result$finished <- base::Sys.time()
[17:28:20.924]     ...future.result
[17:28:20.924] }
[17:28:20.929] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.929] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.930] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.930] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.930] MultisessionFuture started
[17:28:20.931] - Launch lazy future ... done
[17:28:20.931] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-27949'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x0000026676a3daf8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:28:20.944] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.944] - Validating connection of MultisessionFuture
[17:28:20.944] - received message: FutureResult
[17:28:20.944] - Received FutureResult
[17:28:20.945] - Erased future from FutureRegistry
[17:28:20.945] result() for ClusterFuture ...
[17:28:20.945] - result already collected: FutureResult
[17:28:20.945] result() for ClusterFuture ... done
[17:28:20.945] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.945] getGlobalsAndPackages() ...
[17:28:20.946] Searching for globals...
[17:28:20.947] - globals found: [3] '{', 'sample', 'x'
[17:28:20.947] Searching for globals ... DONE
[17:28:20.947] Resolving globals: FALSE
[17:28:20.948] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.948] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.948] - globals: [1] 'x'
[17:28:20.948] 
[17:28:20.949] getGlobalsAndPackages() ... DONE
[17:28:20.949] run() for 'Future' ...
[17:28:20.949] - state: 'created'
[17:28:20.949] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:20.963] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.963] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:20.963]   - Field: 'node'
[17:28:20.964]   - Field: 'label'
[17:28:20.964]   - Field: 'local'
[17:28:20.964]   - Field: 'owner'
[17:28:20.964]   - Field: 'envir'
[17:28:20.964]   - Field: 'workers'
[17:28:20.964]   - Field: 'packages'
[17:28:20.965]   - Field: 'gc'
[17:28:20.965]   - Field: 'conditions'
[17:28:20.965]   - Field: 'persistent'
[17:28:20.965]   - Field: 'expr'
[17:28:20.965]   - Field: 'uuid'
[17:28:20.965]   - Field: 'seed'
[17:28:20.966]   - Field: 'version'
[17:28:20.966]   - Field: 'result'
[17:28:20.966]   - Field: 'asynchronous'
[17:28:20.966]   - Field: 'calls'
[17:28:20.966]   - Field: 'globals'
[17:28:20.967]   - Field: 'stdout'
[17:28:20.967]   - Field: 'earlySignal'
[17:28:20.967]   - Field: 'lazy'
[17:28:20.967]   - Field: 'state'
[17:28:20.967] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:20.967] - Launch lazy future ...
[17:28:20.968] Packages needed by the future expression (n = 0): <none>
[17:28:20.968] Packages needed by future strategies (n = 0): <none>
[17:28:20.968] {
[17:28:20.968]     {
[17:28:20.968]         {
[17:28:20.968]             ...future.startTime <- base::Sys.time()
[17:28:20.968]             {
[17:28:20.968]                 {
[17:28:20.968]                   {
[17:28:20.968]                     {
[17:28:20.968]                       base::local({
[17:28:20.968]                         has_future <- base::requireNamespace("future", 
[17:28:20.968]                           quietly = TRUE)
[17:28:20.968]                         if (has_future) {
[17:28:20.968]                           ns <- base::getNamespace("future")
[17:28:20.968]                           version <- ns[[".package"]][["version"]]
[17:28:20.968]                           if (is.null(version)) 
[17:28:20.968]                             version <- utils::packageVersion("future")
[17:28:20.968]                         }
[17:28:20.968]                         else {
[17:28:20.968]                           version <- NULL
[17:28:20.968]                         }
[17:28:20.968]                         if (!has_future || version < "1.8.0") {
[17:28:20.968]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:20.968]                             "", base::R.version$version.string), 
[17:28:20.968]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:20.968]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:20.968]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:20.968]                               "release", "version")], collapse = " "), 
[17:28:20.968]                             hostname = base::Sys.info()[["nodename"]])
[17:28:20.968]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:20.968]                             info)
[17:28:20.968]                           info <- base::paste(info, collapse = "; ")
[17:28:20.968]                           if (!has_future) {
[17:28:20.968]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:20.968]                               info)
[17:28:20.968]                           }
[17:28:20.968]                           else {
[17:28:20.968]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:20.968]                               info, version)
[17:28:20.968]                           }
[17:28:20.968]                           base::stop(msg)
[17:28:20.968]                         }
[17:28:20.968]                       })
[17:28:20.968]                     }
[17:28:20.968]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:20.968]                     base::options(mc.cores = 1L)
[17:28:20.968]                   }
[17:28:20.968]                   ...future.strategy.old <- future::plan("list")
[17:28:20.968]                   options(future.plan = NULL)
[17:28:20.968]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.968]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:20.968]                 }
[17:28:20.968]                 ...future.workdir <- getwd()
[17:28:20.968]             }
[17:28:20.968]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:20.968]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:20.968]         }
[17:28:20.968]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:20.968]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:20.968]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:20.968]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:20.968]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:20.968]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:20.968]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:20.968]             base::names(...future.oldOptions))
[17:28:20.968]     }
[17:28:20.968]     if (FALSE) {
[17:28:20.968]     }
[17:28:20.968]     else {
[17:28:20.968]         if (TRUE) {
[17:28:20.968]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:20.968]                 open = "w")
[17:28:20.968]         }
[17:28:20.968]         else {
[17:28:20.968]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:20.968]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:20.968]         }
[17:28:20.968]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:20.968]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:20.968]             base::sink(type = "output", split = FALSE)
[17:28:20.968]             base::close(...future.stdout)
[17:28:20.968]         }, add = TRUE)
[17:28:20.968]     }
[17:28:20.968]     ...future.frame <- base::sys.nframe()
[17:28:20.968]     ...future.conditions <- base::list()
[17:28:20.968]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:20.968]     if (FALSE) {
[17:28:20.968]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:20.968]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:20.968]     }
[17:28:20.968]     ...future.result <- base::tryCatch({
[17:28:20.968]         base::withCallingHandlers({
[17:28:20.968]             ...future.value <- base::withVisible(base::local({
[17:28:20.968]                 ...future.makeSendCondition <- base::local({
[17:28:20.968]                   sendCondition <- NULL
[17:28:20.968]                   function(frame = 1L) {
[17:28:20.968]                     if (is.function(sendCondition)) 
[17:28:20.968]                       return(sendCondition)
[17:28:20.968]                     ns <- getNamespace("parallel")
[17:28:20.968]                     if (exists("sendData", mode = "function", 
[17:28:20.968]                       envir = ns)) {
[17:28:20.968]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:20.968]                         envir = ns)
[17:28:20.968]                       envir <- sys.frame(frame)
[17:28:20.968]                       master <- NULL
[17:28:20.968]                       while (!identical(envir, .GlobalEnv) && 
[17:28:20.968]                         !identical(envir, emptyenv())) {
[17:28:20.968]                         if (exists("master", mode = "list", envir = envir, 
[17:28:20.968]                           inherits = FALSE)) {
[17:28:20.968]                           master <- get("master", mode = "list", 
[17:28:20.968]                             envir = envir, inherits = FALSE)
[17:28:20.968]                           if (inherits(master, c("SOCKnode", 
[17:28:20.968]                             "SOCK0node"))) {
[17:28:20.968]                             sendCondition <<- function(cond) {
[17:28:20.968]                               data <- list(type = "VALUE", value = cond, 
[17:28:20.968]                                 success = TRUE)
[17:28:20.968]                               parallel_sendData(master, data)
[17:28:20.968]                             }
[17:28:20.968]                             return(sendCondition)
[17:28:20.968]                           }
[17:28:20.968]                         }
[17:28:20.968]                         frame <- frame + 1L
[17:28:20.968]                         envir <- sys.frame(frame)
[17:28:20.968]                       }
[17:28:20.968]                     }
[17:28:20.968]                     sendCondition <<- function(cond) NULL
[17:28:20.968]                   }
[17:28:20.968]                 })
[17:28:20.968]                 withCallingHandlers({
[17:28:20.968]                   {
[17:28:20.968]                     sample(x, size = 1L)
[17:28:20.968]                   }
[17:28:20.968]                 }, immediateCondition = function(cond) {
[17:28:20.968]                   sendCondition <- ...future.makeSendCondition()
[17:28:20.968]                   sendCondition(cond)
[17:28:20.968]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.968]                   {
[17:28:20.968]                     inherits <- base::inherits
[17:28:20.968]                     invokeRestart <- base::invokeRestart
[17:28:20.968]                     is.null <- base::is.null
[17:28:20.968]                     muffled <- FALSE
[17:28:20.968]                     if (inherits(cond, "message")) {
[17:28:20.968]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:20.968]                       if (muffled) 
[17:28:20.968]                         invokeRestart("muffleMessage")
[17:28:20.968]                     }
[17:28:20.968]                     else if (inherits(cond, "warning")) {
[17:28:20.968]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:20.968]                       if (muffled) 
[17:28:20.968]                         invokeRestart("muffleWarning")
[17:28:20.968]                     }
[17:28:20.968]                     else if (inherits(cond, "condition")) {
[17:28:20.968]                       if (!is.null(pattern)) {
[17:28:20.968]                         computeRestarts <- base::computeRestarts
[17:28:20.968]                         grepl <- base::grepl
[17:28:20.968]                         restarts <- computeRestarts(cond)
[17:28:20.968]                         for (restart in restarts) {
[17:28:20.968]                           name <- restart$name
[17:28:20.968]                           if (is.null(name)) 
[17:28:20.968]                             next
[17:28:20.968]                           if (!grepl(pattern, name)) 
[17:28:20.968]                             next
[17:28:20.968]                           invokeRestart(restart)
[17:28:20.968]                           muffled <- TRUE
[17:28:20.968]                           break
[17:28:20.968]                         }
[17:28:20.968]                       }
[17:28:20.968]                     }
[17:28:20.968]                     invisible(muffled)
[17:28:20.968]                   }
[17:28:20.968]                   muffleCondition(cond)
[17:28:20.968]                 })
[17:28:20.968]             }))
[17:28:20.968]             future::FutureResult(value = ...future.value$value, 
[17:28:20.968]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.968]                   ...future.rng), globalenv = if (FALSE) 
[17:28:20.968]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:20.968]                     ...future.globalenv.names))
[17:28:20.968]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:20.968]         }, condition = base::local({
[17:28:20.968]             c <- base::c
[17:28:20.968]             inherits <- base::inherits
[17:28:20.968]             invokeRestart <- base::invokeRestart
[17:28:20.968]             length <- base::length
[17:28:20.968]             list <- base::list
[17:28:20.968]             seq.int <- base::seq.int
[17:28:20.968]             signalCondition <- base::signalCondition
[17:28:20.968]             sys.calls <- base::sys.calls
[17:28:20.968]             `[[` <- base::`[[`
[17:28:20.968]             `+` <- base::`+`
[17:28:20.968]             `<<-` <- base::`<<-`
[17:28:20.968]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:20.968]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:20.968]                   3L)]
[17:28:20.968]             }
[17:28:20.968]             function(cond) {
[17:28:20.968]                 is_error <- inherits(cond, "error")
[17:28:20.968]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:20.968]                   NULL)
[17:28:20.968]                 if (is_error) {
[17:28:20.968]                   sessionInformation <- function() {
[17:28:20.968]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:20.968]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:20.968]                       search = base::search(), system = base::Sys.info())
[17:28:20.968]                   }
[17:28:20.968]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.968]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:20.968]                     cond$call), session = sessionInformation(), 
[17:28:20.968]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:20.968]                   signalCondition(cond)
[17:28:20.968]                 }
[17:28:20.968]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:20.968]                 "immediateCondition"))) {
[17:28:20.968]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:20.968]                   ...future.conditions[[length(...future.conditions) + 
[17:28:20.968]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:20.968]                   if (TRUE && !signal) {
[17:28:20.968]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.968]                     {
[17:28:20.968]                       inherits <- base::inherits
[17:28:20.968]                       invokeRestart <- base::invokeRestart
[17:28:20.968]                       is.null <- base::is.null
[17:28:20.968]                       muffled <- FALSE
[17:28:20.968]                       if (inherits(cond, "message")) {
[17:28:20.968]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.968]                         if (muffled) 
[17:28:20.968]                           invokeRestart("muffleMessage")
[17:28:20.968]                       }
[17:28:20.968]                       else if (inherits(cond, "warning")) {
[17:28:20.968]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.968]                         if (muffled) 
[17:28:20.968]                           invokeRestart("muffleWarning")
[17:28:20.968]                       }
[17:28:20.968]                       else if (inherits(cond, "condition")) {
[17:28:20.968]                         if (!is.null(pattern)) {
[17:28:20.968]                           computeRestarts <- base::computeRestarts
[17:28:20.968]                           grepl <- base::grepl
[17:28:20.968]                           restarts <- computeRestarts(cond)
[17:28:20.968]                           for (restart in restarts) {
[17:28:20.968]                             name <- restart$name
[17:28:20.968]                             if (is.null(name)) 
[17:28:20.968]                               next
[17:28:20.968]                             if (!grepl(pattern, name)) 
[17:28:20.968]                               next
[17:28:20.968]                             invokeRestart(restart)
[17:28:20.968]                             muffled <- TRUE
[17:28:20.968]                             break
[17:28:20.968]                           }
[17:28:20.968]                         }
[17:28:20.968]                       }
[17:28:20.968]                       invisible(muffled)
[17:28:20.968]                     }
[17:28:20.968]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.968]                   }
[17:28:20.968]                 }
[17:28:20.968]                 else {
[17:28:20.968]                   if (TRUE) {
[17:28:20.968]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:20.968]                     {
[17:28:20.968]                       inherits <- base::inherits
[17:28:20.968]                       invokeRestart <- base::invokeRestart
[17:28:20.968]                       is.null <- base::is.null
[17:28:20.968]                       muffled <- FALSE
[17:28:20.968]                       if (inherits(cond, "message")) {
[17:28:20.968]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:20.968]                         if (muffled) 
[17:28:20.968]                           invokeRestart("muffleMessage")
[17:28:20.968]                       }
[17:28:20.968]                       else if (inherits(cond, "warning")) {
[17:28:20.968]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:20.968]                         if (muffled) 
[17:28:20.968]                           invokeRestart("muffleWarning")
[17:28:20.968]                       }
[17:28:20.968]                       else if (inherits(cond, "condition")) {
[17:28:20.968]                         if (!is.null(pattern)) {
[17:28:20.968]                           computeRestarts <- base::computeRestarts
[17:28:20.968]                           grepl <- base::grepl
[17:28:20.968]                           restarts <- computeRestarts(cond)
[17:28:20.968]                           for (restart in restarts) {
[17:28:20.968]                             name <- restart$name
[17:28:20.968]                             if (is.null(name)) 
[17:28:20.968]                               next
[17:28:20.968]                             if (!grepl(pattern, name)) 
[17:28:20.968]                               next
[17:28:20.968]                             invokeRestart(restart)
[17:28:20.968]                             muffled <- TRUE
[17:28:20.968]                             break
[17:28:20.968]                           }
[17:28:20.968]                         }
[17:28:20.968]                       }
[17:28:20.968]                       invisible(muffled)
[17:28:20.968]                     }
[17:28:20.968]                     muffleCondition(cond, pattern = "^muffle")
[17:28:20.968]                   }
[17:28:20.968]                 }
[17:28:20.968]             }
[17:28:20.968]         }))
[17:28:20.968]     }, error = function(ex) {
[17:28:20.968]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:20.968]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:20.968]                 ...future.rng), started = ...future.startTime, 
[17:28:20.968]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:20.968]             version = "1.8"), class = "FutureResult")
[17:28:20.968]     }, finally = {
[17:28:20.968]         if (!identical(...future.workdir, getwd())) 
[17:28:20.968]             setwd(...future.workdir)
[17:28:20.968]         {
[17:28:20.968]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:20.968]                 ...future.oldOptions$nwarnings <- NULL
[17:28:20.968]             }
[17:28:20.968]             base::options(...future.oldOptions)
[17:28:20.968]             if (.Platform$OS.type == "windows") {
[17:28:20.968]                 old_names <- names(...future.oldEnvVars)
[17:28:20.968]                 envs <- base::Sys.getenv()
[17:28:20.968]                 names <- names(envs)
[17:28:20.968]                 common <- intersect(names, old_names)
[17:28:20.968]                 added <- setdiff(names, old_names)
[17:28:20.968]                 removed <- setdiff(old_names, names)
[17:28:20.968]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:20.968]                   envs[common]]
[17:28:20.968]                 NAMES <- toupper(changed)
[17:28:20.968]                 args <- list()
[17:28:20.968]                 for (kk in seq_along(NAMES)) {
[17:28:20.968]                   name <- changed[[kk]]
[17:28:20.968]                   NAME <- NAMES[[kk]]
[17:28:20.968]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.968]                     next
[17:28:20.968]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.968]                 }
[17:28:20.968]                 NAMES <- toupper(added)
[17:28:20.968]                 for (kk in seq_along(NAMES)) {
[17:28:20.968]                   name <- added[[kk]]
[17:28:20.968]                   NAME <- NAMES[[kk]]
[17:28:20.968]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.968]                     next
[17:28:20.968]                   args[[name]] <- ""
[17:28:20.968]                 }
[17:28:20.968]                 NAMES <- toupper(removed)
[17:28:20.968]                 for (kk in seq_along(NAMES)) {
[17:28:20.968]                   name <- removed[[kk]]
[17:28:20.968]                   NAME <- NAMES[[kk]]
[17:28:20.968]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:20.968]                     next
[17:28:20.968]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:20.968]                 }
[17:28:20.968]                 if (length(args) > 0) 
[17:28:20.968]                   base::do.call(base::Sys.setenv, args = args)
[17:28:20.968]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:20.968]             }
[17:28:20.968]             else {
[17:28:20.968]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:20.968]             }
[17:28:20.968]             {
[17:28:20.968]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:20.968]                   0L) {
[17:28:20.968]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:20.968]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:20.968]                   base::options(opts)
[17:28:20.968]                 }
[17:28:20.968]                 {
[17:28:20.968]                   {
[17:28:20.968]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:20.968]                     NULL
[17:28:20.968]                   }
[17:28:20.968]                   options(future.plan = NULL)
[17:28:20.968]                   if (is.na(NA_character_)) 
[17:28:20.968]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:20.968]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:20.968]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:20.968]                     .init = FALSE)
[17:28:20.968]                 }
[17:28:20.968]             }
[17:28:20.968]         }
[17:28:20.968]     })
[17:28:20.968]     if (TRUE) {
[17:28:20.968]         base::sink(type = "output", split = FALSE)
[17:28:20.968]         if (TRUE) {
[17:28:20.968]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:20.968]         }
[17:28:20.968]         else {
[17:28:20.968]             ...future.result["stdout"] <- base::list(NULL)
[17:28:20.968]         }
[17:28:20.968]         base::close(...future.stdout)
[17:28:20.968]         ...future.stdout <- NULL
[17:28:20.968]     }
[17:28:20.968]     ...future.result$conditions <- ...future.conditions
[17:28:20.968]     ...future.result$finished <- base::Sys.time()
[17:28:20.968]     ...future.result
[17:28:20.968] }
[17:28:20.974] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:20.974] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:20.974] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:20.974] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:20.975] MultisessionFuture started
[17:28:20.975] - Launch lazy future ... done
[17:28:20.975] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-741930'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x0000026676a3daf8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:28:20.989] receiveMessageFromWorker() for ClusterFuture ...
[17:28:20.989] - Validating connection of MultisessionFuture
[17:28:20.990] - received message: FutureResult
[17:28:20.990] - Received FutureResult
[17:28:20.990] - Erased future from FutureRegistry
[17:28:20.990] result() for ClusterFuture ...
[17:28:20.990] - result already collected: FutureResult
[17:28:20.991] result() for ClusterFuture ... done
[17:28:20.991] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:20.991] getGlobalsAndPackages() ...
[17:28:20.991] Searching for globals...
[17:28:20.994] - globals found: [3] '{', 'sample', 'x'
[17:28:20.995] Searching for globals ... DONE
[17:28:20.995] Resolving globals: FALSE
[17:28:20.995] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:20.996] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:20.996] - globals: [1] 'x'
[17:28:20.996] 
[17:28:20.996] getGlobalsAndPackages() ... DONE
[17:28:20.996] run() for 'Future' ...
[17:28:20.997] - state: 'created'
[17:28:20.997] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.011] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.011] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.011]   - Field: 'node'
[17:28:21.012]   - Field: 'label'
[17:28:21.012]   - Field: 'local'
[17:28:21.012]   - Field: 'owner'
[17:28:21.012]   - Field: 'envir'
[17:28:21.012]   - Field: 'workers'
[17:28:21.013]   - Field: 'packages'
[17:28:21.013]   - Field: 'gc'
[17:28:21.013]   - Field: 'conditions'
[17:28:21.013]   - Field: 'persistent'
[17:28:21.013]   - Field: 'expr'
[17:28:21.013]   - Field: 'uuid'
[17:28:21.014]   - Field: 'seed'
[17:28:21.014]   - Field: 'version'
[17:28:21.014]   - Field: 'result'
[17:28:21.014]   - Field: 'asynchronous'
[17:28:21.014]   - Field: 'calls'
[17:28:21.014]   - Field: 'globals'
[17:28:21.015]   - Field: 'stdout'
[17:28:21.015]   - Field: 'earlySignal'
[17:28:21.015]   - Field: 'lazy'
[17:28:21.015]   - Field: 'state'
[17:28:21.015] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.015] - Launch lazy future ...
[17:28:21.016] Packages needed by the future expression (n = 0): <none>
[17:28:21.016] Packages needed by future strategies (n = 0): <none>
[17:28:21.017] {
[17:28:21.017]     {
[17:28:21.017]         {
[17:28:21.017]             ...future.startTime <- base::Sys.time()
[17:28:21.017]             {
[17:28:21.017]                 {
[17:28:21.017]                   {
[17:28:21.017]                     {
[17:28:21.017]                       base::local({
[17:28:21.017]                         has_future <- base::requireNamespace("future", 
[17:28:21.017]                           quietly = TRUE)
[17:28:21.017]                         if (has_future) {
[17:28:21.017]                           ns <- base::getNamespace("future")
[17:28:21.017]                           version <- ns[[".package"]][["version"]]
[17:28:21.017]                           if (is.null(version)) 
[17:28:21.017]                             version <- utils::packageVersion("future")
[17:28:21.017]                         }
[17:28:21.017]                         else {
[17:28:21.017]                           version <- NULL
[17:28:21.017]                         }
[17:28:21.017]                         if (!has_future || version < "1.8.0") {
[17:28:21.017]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.017]                             "", base::R.version$version.string), 
[17:28:21.017]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:21.017]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:21.017]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.017]                               "release", "version")], collapse = " "), 
[17:28:21.017]                             hostname = base::Sys.info()[["nodename"]])
[17:28:21.017]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.017]                             info)
[17:28:21.017]                           info <- base::paste(info, collapse = "; ")
[17:28:21.017]                           if (!has_future) {
[17:28:21.017]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.017]                               info)
[17:28:21.017]                           }
[17:28:21.017]                           else {
[17:28:21.017]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.017]                               info, version)
[17:28:21.017]                           }
[17:28:21.017]                           base::stop(msg)
[17:28:21.017]                         }
[17:28:21.017]                       })
[17:28:21.017]                     }
[17:28:21.017]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.017]                     base::options(mc.cores = 1L)
[17:28:21.017]                   }
[17:28:21.017]                   ...future.strategy.old <- future::plan("list")
[17:28:21.017]                   options(future.plan = NULL)
[17:28:21.017]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.017]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:21.017]                 }
[17:28:21.017]                 ...future.workdir <- getwd()
[17:28:21.017]             }
[17:28:21.017]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.017]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.017]         }
[17:28:21.017]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.017]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.017]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.017]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.017]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.017]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.017]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.017]             base::names(...future.oldOptions))
[17:28:21.017]     }
[17:28:21.017]     if (FALSE) {
[17:28:21.017]     }
[17:28:21.017]     else {
[17:28:21.017]         if (TRUE) {
[17:28:21.017]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.017]                 open = "w")
[17:28:21.017]         }
[17:28:21.017]         else {
[17:28:21.017]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.017]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.017]         }
[17:28:21.017]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.017]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.017]             base::sink(type = "output", split = FALSE)
[17:28:21.017]             base::close(...future.stdout)
[17:28:21.017]         }, add = TRUE)
[17:28:21.017]     }
[17:28:21.017]     ...future.frame <- base::sys.nframe()
[17:28:21.017]     ...future.conditions <- base::list()
[17:28:21.017]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.017]     if (FALSE) {
[17:28:21.017]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.017]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.017]     }
[17:28:21.017]     ...future.result <- base::tryCatch({
[17:28:21.017]         base::withCallingHandlers({
[17:28:21.017]             ...future.value <- base::withVisible(base::local({
[17:28:21.017]                 ...future.makeSendCondition <- base::local({
[17:28:21.017]                   sendCondition <- NULL
[17:28:21.017]                   function(frame = 1L) {
[17:28:21.017]                     if (is.function(sendCondition)) 
[17:28:21.017]                       return(sendCondition)
[17:28:21.017]                     ns <- getNamespace("parallel")
[17:28:21.017]                     if (exists("sendData", mode = "function", 
[17:28:21.017]                       envir = ns)) {
[17:28:21.017]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.017]                         envir = ns)
[17:28:21.017]                       envir <- sys.frame(frame)
[17:28:21.017]                       master <- NULL
[17:28:21.017]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.017]                         !identical(envir, emptyenv())) {
[17:28:21.017]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.017]                           inherits = FALSE)) {
[17:28:21.017]                           master <- get("master", mode = "list", 
[17:28:21.017]                             envir = envir, inherits = FALSE)
[17:28:21.017]                           if (inherits(master, c("SOCKnode", 
[17:28:21.017]                             "SOCK0node"))) {
[17:28:21.017]                             sendCondition <<- function(cond) {
[17:28:21.017]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.017]                                 success = TRUE)
[17:28:21.017]                               parallel_sendData(master, data)
[17:28:21.017]                             }
[17:28:21.017]                             return(sendCondition)
[17:28:21.017]                           }
[17:28:21.017]                         }
[17:28:21.017]                         frame <- frame + 1L
[17:28:21.017]                         envir <- sys.frame(frame)
[17:28:21.017]                       }
[17:28:21.017]                     }
[17:28:21.017]                     sendCondition <<- function(cond) NULL
[17:28:21.017]                   }
[17:28:21.017]                 })
[17:28:21.017]                 withCallingHandlers({
[17:28:21.017]                   {
[17:28:21.017]                     sample(x, size = 1L)
[17:28:21.017]                   }
[17:28:21.017]                 }, immediateCondition = function(cond) {
[17:28:21.017]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.017]                   sendCondition(cond)
[17:28:21.017]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.017]                   {
[17:28:21.017]                     inherits <- base::inherits
[17:28:21.017]                     invokeRestart <- base::invokeRestart
[17:28:21.017]                     is.null <- base::is.null
[17:28:21.017]                     muffled <- FALSE
[17:28:21.017]                     if (inherits(cond, "message")) {
[17:28:21.017]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.017]                       if (muffled) 
[17:28:21.017]                         invokeRestart("muffleMessage")
[17:28:21.017]                     }
[17:28:21.017]                     else if (inherits(cond, "warning")) {
[17:28:21.017]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.017]                       if (muffled) 
[17:28:21.017]                         invokeRestart("muffleWarning")
[17:28:21.017]                     }
[17:28:21.017]                     else if (inherits(cond, "condition")) {
[17:28:21.017]                       if (!is.null(pattern)) {
[17:28:21.017]                         computeRestarts <- base::computeRestarts
[17:28:21.017]                         grepl <- base::grepl
[17:28:21.017]                         restarts <- computeRestarts(cond)
[17:28:21.017]                         for (restart in restarts) {
[17:28:21.017]                           name <- restart$name
[17:28:21.017]                           if (is.null(name)) 
[17:28:21.017]                             next
[17:28:21.017]                           if (!grepl(pattern, name)) 
[17:28:21.017]                             next
[17:28:21.017]                           invokeRestart(restart)
[17:28:21.017]                           muffled <- TRUE
[17:28:21.017]                           break
[17:28:21.017]                         }
[17:28:21.017]                       }
[17:28:21.017]                     }
[17:28:21.017]                     invisible(muffled)
[17:28:21.017]                   }
[17:28:21.017]                   muffleCondition(cond)
[17:28:21.017]                 })
[17:28:21.017]             }))
[17:28:21.017]             future::FutureResult(value = ...future.value$value, 
[17:28:21.017]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.017]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.017]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.017]                     ...future.globalenv.names))
[17:28:21.017]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.017]         }, condition = base::local({
[17:28:21.017]             c <- base::c
[17:28:21.017]             inherits <- base::inherits
[17:28:21.017]             invokeRestart <- base::invokeRestart
[17:28:21.017]             length <- base::length
[17:28:21.017]             list <- base::list
[17:28:21.017]             seq.int <- base::seq.int
[17:28:21.017]             signalCondition <- base::signalCondition
[17:28:21.017]             sys.calls <- base::sys.calls
[17:28:21.017]             `[[` <- base::`[[`
[17:28:21.017]             `+` <- base::`+`
[17:28:21.017]             `<<-` <- base::`<<-`
[17:28:21.017]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.017]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.017]                   3L)]
[17:28:21.017]             }
[17:28:21.017]             function(cond) {
[17:28:21.017]                 is_error <- inherits(cond, "error")
[17:28:21.017]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.017]                   NULL)
[17:28:21.017]                 if (is_error) {
[17:28:21.017]                   sessionInformation <- function() {
[17:28:21.017]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.017]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.017]                       search = base::search(), system = base::Sys.info())
[17:28:21.017]                   }
[17:28:21.017]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.017]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.017]                     cond$call), session = sessionInformation(), 
[17:28:21.017]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.017]                   signalCondition(cond)
[17:28:21.017]                 }
[17:28:21.017]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.017]                 "immediateCondition"))) {
[17:28:21.017]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.017]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.017]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.017]                   if (TRUE && !signal) {
[17:28:21.017]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.017]                     {
[17:28:21.017]                       inherits <- base::inherits
[17:28:21.017]                       invokeRestart <- base::invokeRestart
[17:28:21.017]                       is.null <- base::is.null
[17:28:21.017]                       muffled <- FALSE
[17:28:21.017]                       if (inherits(cond, "message")) {
[17:28:21.017]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.017]                         if (muffled) 
[17:28:21.017]                           invokeRestart("muffleMessage")
[17:28:21.017]                       }
[17:28:21.017]                       else if (inherits(cond, "warning")) {
[17:28:21.017]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.017]                         if (muffled) 
[17:28:21.017]                           invokeRestart("muffleWarning")
[17:28:21.017]                       }
[17:28:21.017]                       else if (inherits(cond, "condition")) {
[17:28:21.017]                         if (!is.null(pattern)) {
[17:28:21.017]                           computeRestarts <- base::computeRestarts
[17:28:21.017]                           grepl <- base::grepl
[17:28:21.017]                           restarts <- computeRestarts(cond)
[17:28:21.017]                           for (restart in restarts) {
[17:28:21.017]                             name <- restart$name
[17:28:21.017]                             if (is.null(name)) 
[17:28:21.017]                               next
[17:28:21.017]                             if (!grepl(pattern, name)) 
[17:28:21.017]                               next
[17:28:21.017]                             invokeRestart(restart)
[17:28:21.017]                             muffled <- TRUE
[17:28:21.017]                             break
[17:28:21.017]                           }
[17:28:21.017]                         }
[17:28:21.017]                       }
[17:28:21.017]                       invisible(muffled)
[17:28:21.017]                     }
[17:28:21.017]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.017]                   }
[17:28:21.017]                 }
[17:28:21.017]                 else {
[17:28:21.017]                   if (TRUE) {
[17:28:21.017]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.017]                     {
[17:28:21.017]                       inherits <- base::inherits
[17:28:21.017]                       invokeRestart <- base::invokeRestart
[17:28:21.017]                       is.null <- base::is.null
[17:28:21.017]                       muffled <- FALSE
[17:28:21.017]                       if (inherits(cond, "message")) {
[17:28:21.017]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.017]                         if (muffled) 
[17:28:21.017]                           invokeRestart("muffleMessage")
[17:28:21.017]                       }
[17:28:21.017]                       else if (inherits(cond, "warning")) {
[17:28:21.017]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.017]                         if (muffled) 
[17:28:21.017]                           invokeRestart("muffleWarning")
[17:28:21.017]                       }
[17:28:21.017]                       else if (inherits(cond, "condition")) {
[17:28:21.017]                         if (!is.null(pattern)) {
[17:28:21.017]                           computeRestarts <- base::computeRestarts
[17:28:21.017]                           grepl <- base::grepl
[17:28:21.017]                           restarts <- computeRestarts(cond)
[17:28:21.017]                           for (restart in restarts) {
[17:28:21.017]                             name <- restart$name
[17:28:21.017]                             if (is.null(name)) 
[17:28:21.017]                               next
[17:28:21.017]                             if (!grepl(pattern, name)) 
[17:28:21.017]                               next
[17:28:21.017]                             invokeRestart(restart)
[17:28:21.017]                             muffled <- TRUE
[17:28:21.017]                             break
[17:28:21.017]                           }
[17:28:21.017]                         }
[17:28:21.017]                       }
[17:28:21.017]                       invisible(muffled)
[17:28:21.017]                     }
[17:28:21.017]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.017]                   }
[17:28:21.017]                 }
[17:28:21.017]             }
[17:28:21.017]         }))
[17:28:21.017]     }, error = function(ex) {
[17:28:21.017]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.017]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.017]                 ...future.rng), started = ...future.startTime, 
[17:28:21.017]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.017]             version = "1.8"), class = "FutureResult")
[17:28:21.017]     }, finally = {
[17:28:21.017]         if (!identical(...future.workdir, getwd())) 
[17:28:21.017]             setwd(...future.workdir)
[17:28:21.017]         {
[17:28:21.017]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.017]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.017]             }
[17:28:21.017]             base::options(...future.oldOptions)
[17:28:21.017]             if (.Platform$OS.type == "windows") {
[17:28:21.017]                 old_names <- names(...future.oldEnvVars)
[17:28:21.017]                 envs <- base::Sys.getenv()
[17:28:21.017]                 names <- names(envs)
[17:28:21.017]                 common <- intersect(names, old_names)
[17:28:21.017]                 added <- setdiff(names, old_names)
[17:28:21.017]                 removed <- setdiff(old_names, names)
[17:28:21.017]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.017]                   envs[common]]
[17:28:21.017]                 NAMES <- toupper(changed)
[17:28:21.017]                 args <- list()
[17:28:21.017]                 for (kk in seq_along(NAMES)) {
[17:28:21.017]                   name <- changed[[kk]]
[17:28:21.017]                   NAME <- NAMES[[kk]]
[17:28:21.017]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.017]                     next
[17:28:21.017]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.017]                 }
[17:28:21.017]                 NAMES <- toupper(added)
[17:28:21.017]                 for (kk in seq_along(NAMES)) {
[17:28:21.017]                   name <- added[[kk]]
[17:28:21.017]                   NAME <- NAMES[[kk]]
[17:28:21.017]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.017]                     next
[17:28:21.017]                   args[[name]] <- ""
[17:28:21.017]                 }
[17:28:21.017]                 NAMES <- toupper(removed)
[17:28:21.017]                 for (kk in seq_along(NAMES)) {
[17:28:21.017]                   name <- removed[[kk]]
[17:28:21.017]                   NAME <- NAMES[[kk]]
[17:28:21.017]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.017]                     next
[17:28:21.017]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.017]                 }
[17:28:21.017]                 if (length(args) > 0) 
[17:28:21.017]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.017]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.017]             }
[17:28:21.017]             else {
[17:28:21.017]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.017]             }
[17:28:21.017]             {
[17:28:21.017]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.017]                   0L) {
[17:28:21.017]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.017]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.017]                   base::options(opts)
[17:28:21.017]                 }
[17:28:21.017]                 {
[17:28:21.017]                   {
[17:28:21.017]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.017]                     NULL
[17:28:21.017]                   }
[17:28:21.017]                   options(future.plan = NULL)
[17:28:21.017]                   if (is.na(NA_character_)) 
[17:28:21.017]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.017]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.017]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.017]                     .init = FALSE)
[17:28:21.017]                 }
[17:28:21.017]             }
[17:28:21.017]         }
[17:28:21.017]     })
[17:28:21.017]     if (TRUE) {
[17:28:21.017]         base::sink(type = "output", split = FALSE)
[17:28:21.017]         if (TRUE) {
[17:28:21.017]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.017]         }
[17:28:21.017]         else {
[17:28:21.017]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.017]         }
[17:28:21.017]         base::close(...future.stdout)
[17:28:21.017]         ...future.stdout <- NULL
[17:28:21.017]     }
[17:28:21.017]     ...future.result$conditions <- ...future.conditions
[17:28:21.017]     ...future.result$finished <- base::Sys.time()
[17:28:21.017]     ...future.result
[17:28:21.017] }
[17:28:21.021] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:21.022] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:21.022] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:21.022] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:21.023] MultisessionFuture started
[17:28:21.023] - Launch lazy future ... done
[17:28:21.023] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-183121'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x0000026676a3daf8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:28:21.037] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.037] - Validating connection of MultisessionFuture
[17:28:21.037] - received message: FutureResult
[17:28:21.038] - Received FutureResult
[17:28:21.038] - Erased future from FutureRegistry
[17:28:21.038] result() for ClusterFuture ...
[17:28:21.038] - result already collected: FutureResult
[17:28:21.038] result() for ClusterFuture ... done
[17:28:21.038] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.039] getGlobalsAndPackages() ...
[17:28:21.039] Searching for globals...
[17:28:21.040] - globals found: [3] '{', 'sample', 'x'
[17:28:21.040] Searching for globals ... DONE
[17:28:21.040] Resolving globals: FALSE
[17:28:21.041] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.041] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.042] - globals: [1] 'x'
[17:28:21.042] 
[17:28:21.042] getGlobalsAndPackages() ... DONE
[17:28:21.042] run() for 'Future' ...
[17:28:21.042] - state: 'created'
[17:28:21.043] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.058] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.059] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.059]   - Field: 'node'
[17:28:21.059]   - Field: 'label'
[17:28:21.059]   - Field: 'local'
[17:28:21.059]   - Field: 'owner'
[17:28:21.060]   - Field: 'envir'
[17:28:21.060]   - Field: 'workers'
[17:28:21.060]   - Field: 'packages'
[17:28:21.060]   - Field: 'gc'
[17:28:21.060]   - Field: 'conditions'
[17:28:21.060]   - Field: 'persistent'
[17:28:21.061]   - Field: 'expr'
[17:28:21.061]   - Field: 'uuid'
[17:28:21.061]   - Field: 'seed'
[17:28:21.061]   - Field: 'version'
[17:28:21.061]   - Field: 'result'
[17:28:21.061]   - Field: 'asynchronous'
[17:28:21.062]   - Field: 'calls'
[17:28:21.062]   - Field: 'globals'
[17:28:21.062]   - Field: 'stdout'
[17:28:21.062]   - Field: 'earlySignal'
[17:28:21.062]   - Field: 'lazy'
[17:28:21.063]   - Field: 'state'
[17:28:21.063] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.063] - Launch lazy future ...
[17:28:21.063] Packages needed by the future expression (n = 0): <none>
[17:28:21.063] Packages needed by future strategies (n = 0): <none>
[17:28:21.064] {
[17:28:21.064]     {
[17:28:21.064]         {
[17:28:21.064]             ...future.startTime <- base::Sys.time()
[17:28:21.064]             {
[17:28:21.064]                 {
[17:28:21.064]                   {
[17:28:21.064]                     {
[17:28:21.064]                       base::local({
[17:28:21.064]                         has_future <- base::requireNamespace("future", 
[17:28:21.064]                           quietly = TRUE)
[17:28:21.064]                         if (has_future) {
[17:28:21.064]                           ns <- base::getNamespace("future")
[17:28:21.064]                           version <- ns[[".package"]][["version"]]
[17:28:21.064]                           if (is.null(version)) 
[17:28:21.064]                             version <- utils::packageVersion("future")
[17:28:21.064]                         }
[17:28:21.064]                         else {
[17:28:21.064]                           version <- NULL
[17:28:21.064]                         }
[17:28:21.064]                         if (!has_future || version < "1.8.0") {
[17:28:21.064]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.064]                             "", base::R.version$version.string), 
[17:28:21.064]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:21.064]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:21.064]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.064]                               "release", "version")], collapse = " "), 
[17:28:21.064]                             hostname = base::Sys.info()[["nodename"]])
[17:28:21.064]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.064]                             info)
[17:28:21.064]                           info <- base::paste(info, collapse = "; ")
[17:28:21.064]                           if (!has_future) {
[17:28:21.064]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.064]                               info)
[17:28:21.064]                           }
[17:28:21.064]                           else {
[17:28:21.064]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.064]                               info, version)
[17:28:21.064]                           }
[17:28:21.064]                           base::stop(msg)
[17:28:21.064]                         }
[17:28:21.064]                       })
[17:28:21.064]                     }
[17:28:21.064]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.064]                     base::options(mc.cores = 1L)
[17:28:21.064]                   }
[17:28:21.064]                   ...future.strategy.old <- future::plan("list")
[17:28:21.064]                   options(future.plan = NULL)
[17:28:21.064]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.064]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:21.064]                 }
[17:28:21.064]                 ...future.workdir <- getwd()
[17:28:21.064]             }
[17:28:21.064]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.064]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.064]         }
[17:28:21.064]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.064]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.064]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.064]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.064]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.064]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.064]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.064]             base::names(...future.oldOptions))
[17:28:21.064]     }
[17:28:21.064]     if (FALSE) {
[17:28:21.064]     }
[17:28:21.064]     else {
[17:28:21.064]         if (TRUE) {
[17:28:21.064]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.064]                 open = "w")
[17:28:21.064]         }
[17:28:21.064]         else {
[17:28:21.064]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.064]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.064]         }
[17:28:21.064]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.064]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.064]             base::sink(type = "output", split = FALSE)
[17:28:21.064]             base::close(...future.stdout)
[17:28:21.064]         }, add = TRUE)
[17:28:21.064]     }
[17:28:21.064]     ...future.frame <- base::sys.nframe()
[17:28:21.064]     ...future.conditions <- base::list()
[17:28:21.064]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.064]     if (FALSE) {
[17:28:21.064]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.064]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.064]     }
[17:28:21.064]     ...future.result <- base::tryCatch({
[17:28:21.064]         base::withCallingHandlers({
[17:28:21.064]             ...future.value <- base::withVisible(base::local({
[17:28:21.064]                 ...future.makeSendCondition <- base::local({
[17:28:21.064]                   sendCondition <- NULL
[17:28:21.064]                   function(frame = 1L) {
[17:28:21.064]                     if (is.function(sendCondition)) 
[17:28:21.064]                       return(sendCondition)
[17:28:21.064]                     ns <- getNamespace("parallel")
[17:28:21.064]                     if (exists("sendData", mode = "function", 
[17:28:21.064]                       envir = ns)) {
[17:28:21.064]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.064]                         envir = ns)
[17:28:21.064]                       envir <- sys.frame(frame)
[17:28:21.064]                       master <- NULL
[17:28:21.064]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.064]                         !identical(envir, emptyenv())) {
[17:28:21.064]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.064]                           inherits = FALSE)) {
[17:28:21.064]                           master <- get("master", mode = "list", 
[17:28:21.064]                             envir = envir, inherits = FALSE)
[17:28:21.064]                           if (inherits(master, c("SOCKnode", 
[17:28:21.064]                             "SOCK0node"))) {
[17:28:21.064]                             sendCondition <<- function(cond) {
[17:28:21.064]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.064]                                 success = TRUE)
[17:28:21.064]                               parallel_sendData(master, data)
[17:28:21.064]                             }
[17:28:21.064]                             return(sendCondition)
[17:28:21.064]                           }
[17:28:21.064]                         }
[17:28:21.064]                         frame <- frame + 1L
[17:28:21.064]                         envir <- sys.frame(frame)
[17:28:21.064]                       }
[17:28:21.064]                     }
[17:28:21.064]                     sendCondition <<- function(cond) NULL
[17:28:21.064]                   }
[17:28:21.064]                 })
[17:28:21.064]                 withCallingHandlers({
[17:28:21.064]                   {
[17:28:21.064]                     sample(x, size = 1L)
[17:28:21.064]                   }
[17:28:21.064]                 }, immediateCondition = function(cond) {
[17:28:21.064]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.064]                   sendCondition(cond)
[17:28:21.064]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.064]                   {
[17:28:21.064]                     inherits <- base::inherits
[17:28:21.064]                     invokeRestart <- base::invokeRestart
[17:28:21.064]                     is.null <- base::is.null
[17:28:21.064]                     muffled <- FALSE
[17:28:21.064]                     if (inherits(cond, "message")) {
[17:28:21.064]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.064]                       if (muffled) 
[17:28:21.064]                         invokeRestart("muffleMessage")
[17:28:21.064]                     }
[17:28:21.064]                     else if (inherits(cond, "warning")) {
[17:28:21.064]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.064]                       if (muffled) 
[17:28:21.064]                         invokeRestart("muffleWarning")
[17:28:21.064]                     }
[17:28:21.064]                     else if (inherits(cond, "condition")) {
[17:28:21.064]                       if (!is.null(pattern)) {
[17:28:21.064]                         computeRestarts <- base::computeRestarts
[17:28:21.064]                         grepl <- base::grepl
[17:28:21.064]                         restarts <- computeRestarts(cond)
[17:28:21.064]                         for (restart in restarts) {
[17:28:21.064]                           name <- restart$name
[17:28:21.064]                           if (is.null(name)) 
[17:28:21.064]                             next
[17:28:21.064]                           if (!grepl(pattern, name)) 
[17:28:21.064]                             next
[17:28:21.064]                           invokeRestart(restart)
[17:28:21.064]                           muffled <- TRUE
[17:28:21.064]                           break
[17:28:21.064]                         }
[17:28:21.064]                       }
[17:28:21.064]                     }
[17:28:21.064]                     invisible(muffled)
[17:28:21.064]                   }
[17:28:21.064]                   muffleCondition(cond)
[17:28:21.064]                 })
[17:28:21.064]             }))
[17:28:21.064]             future::FutureResult(value = ...future.value$value, 
[17:28:21.064]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.064]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.064]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.064]                     ...future.globalenv.names))
[17:28:21.064]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.064]         }, condition = base::local({
[17:28:21.064]             c <- base::c
[17:28:21.064]             inherits <- base::inherits
[17:28:21.064]             invokeRestart <- base::invokeRestart
[17:28:21.064]             length <- base::length
[17:28:21.064]             list <- base::list
[17:28:21.064]             seq.int <- base::seq.int
[17:28:21.064]             signalCondition <- base::signalCondition
[17:28:21.064]             sys.calls <- base::sys.calls
[17:28:21.064]             `[[` <- base::`[[`
[17:28:21.064]             `+` <- base::`+`
[17:28:21.064]             `<<-` <- base::`<<-`
[17:28:21.064]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.064]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.064]                   3L)]
[17:28:21.064]             }
[17:28:21.064]             function(cond) {
[17:28:21.064]                 is_error <- inherits(cond, "error")
[17:28:21.064]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.064]                   NULL)
[17:28:21.064]                 if (is_error) {
[17:28:21.064]                   sessionInformation <- function() {
[17:28:21.064]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.064]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.064]                       search = base::search(), system = base::Sys.info())
[17:28:21.064]                   }
[17:28:21.064]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.064]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.064]                     cond$call), session = sessionInformation(), 
[17:28:21.064]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.064]                   signalCondition(cond)
[17:28:21.064]                 }
[17:28:21.064]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.064]                 "immediateCondition"))) {
[17:28:21.064]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.064]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.064]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.064]                   if (TRUE && !signal) {
[17:28:21.064]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.064]                     {
[17:28:21.064]                       inherits <- base::inherits
[17:28:21.064]                       invokeRestart <- base::invokeRestart
[17:28:21.064]                       is.null <- base::is.null
[17:28:21.064]                       muffled <- FALSE
[17:28:21.064]                       if (inherits(cond, "message")) {
[17:28:21.064]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.064]                         if (muffled) 
[17:28:21.064]                           invokeRestart("muffleMessage")
[17:28:21.064]                       }
[17:28:21.064]                       else if (inherits(cond, "warning")) {
[17:28:21.064]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.064]                         if (muffled) 
[17:28:21.064]                           invokeRestart("muffleWarning")
[17:28:21.064]                       }
[17:28:21.064]                       else if (inherits(cond, "condition")) {
[17:28:21.064]                         if (!is.null(pattern)) {
[17:28:21.064]                           computeRestarts <- base::computeRestarts
[17:28:21.064]                           grepl <- base::grepl
[17:28:21.064]                           restarts <- computeRestarts(cond)
[17:28:21.064]                           for (restart in restarts) {
[17:28:21.064]                             name <- restart$name
[17:28:21.064]                             if (is.null(name)) 
[17:28:21.064]                               next
[17:28:21.064]                             if (!grepl(pattern, name)) 
[17:28:21.064]                               next
[17:28:21.064]                             invokeRestart(restart)
[17:28:21.064]                             muffled <- TRUE
[17:28:21.064]                             break
[17:28:21.064]                           }
[17:28:21.064]                         }
[17:28:21.064]                       }
[17:28:21.064]                       invisible(muffled)
[17:28:21.064]                     }
[17:28:21.064]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.064]                   }
[17:28:21.064]                 }
[17:28:21.064]                 else {
[17:28:21.064]                   if (TRUE) {
[17:28:21.064]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.064]                     {
[17:28:21.064]                       inherits <- base::inherits
[17:28:21.064]                       invokeRestart <- base::invokeRestart
[17:28:21.064]                       is.null <- base::is.null
[17:28:21.064]                       muffled <- FALSE
[17:28:21.064]                       if (inherits(cond, "message")) {
[17:28:21.064]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.064]                         if (muffled) 
[17:28:21.064]                           invokeRestart("muffleMessage")
[17:28:21.064]                       }
[17:28:21.064]                       else if (inherits(cond, "warning")) {
[17:28:21.064]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.064]                         if (muffled) 
[17:28:21.064]                           invokeRestart("muffleWarning")
[17:28:21.064]                       }
[17:28:21.064]                       else if (inherits(cond, "condition")) {
[17:28:21.064]                         if (!is.null(pattern)) {
[17:28:21.064]                           computeRestarts <- base::computeRestarts
[17:28:21.064]                           grepl <- base::grepl
[17:28:21.064]                           restarts <- computeRestarts(cond)
[17:28:21.064]                           for (restart in restarts) {
[17:28:21.064]                             name <- restart$name
[17:28:21.064]                             if (is.null(name)) 
[17:28:21.064]                               next
[17:28:21.064]                             if (!grepl(pattern, name)) 
[17:28:21.064]                               next
[17:28:21.064]                             invokeRestart(restart)
[17:28:21.064]                             muffled <- TRUE
[17:28:21.064]                             break
[17:28:21.064]                           }
[17:28:21.064]                         }
[17:28:21.064]                       }
[17:28:21.064]                       invisible(muffled)
[17:28:21.064]                     }
[17:28:21.064]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.064]                   }
[17:28:21.064]                 }
[17:28:21.064]             }
[17:28:21.064]         }))
[17:28:21.064]     }, error = function(ex) {
[17:28:21.064]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.064]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.064]                 ...future.rng), started = ...future.startTime, 
[17:28:21.064]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.064]             version = "1.8"), class = "FutureResult")
[17:28:21.064]     }, finally = {
[17:28:21.064]         if (!identical(...future.workdir, getwd())) 
[17:28:21.064]             setwd(...future.workdir)
[17:28:21.064]         {
[17:28:21.064]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.064]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.064]             }
[17:28:21.064]             base::options(...future.oldOptions)
[17:28:21.064]             if (.Platform$OS.type == "windows") {
[17:28:21.064]                 old_names <- names(...future.oldEnvVars)
[17:28:21.064]                 envs <- base::Sys.getenv()
[17:28:21.064]                 names <- names(envs)
[17:28:21.064]                 common <- intersect(names, old_names)
[17:28:21.064]                 added <- setdiff(names, old_names)
[17:28:21.064]                 removed <- setdiff(old_names, names)
[17:28:21.064]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.064]                   envs[common]]
[17:28:21.064]                 NAMES <- toupper(changed)
[17:28:21.064]                 args <- list()
[17:28:21.064]                 for (kk in seq_along(NAMES)) {
[17:28:21.064]                   name <- changed[[kk]]
[17:28:21.064]                   NAME <- NAMES[[kk]]
[17:28:21.064]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.064]                     next
[17:28:21.064]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.064]                 }
[17:28:21.064]                 NAMES <- toupper(added)
[17:28:21.064]                 for (kk in seq_along(NAMES)) {
[17:28:21.064]                   name <- added[[kk]]
[17:28:21.064]                   NAME <- NAMES[[kk]]
[17:28:21.064]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.064]                     next
[17:28:21.064]                   args[[name]] <- ""
[17:28:21.064]                 }
[17:28:21.064]                 NAMES <- toupper(removed)
[17:28:21.064]                 for (kk in seq_along(NAMES)) {
[17:28:21.064]                   name <- removed[[kk]]
[17:28:21.064]                   NAME <- NAMES[[kk]]
[17:28:21.064]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.064]                     next
[17:28:21.064]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.064]                 }
[17:28:21.064]                 if (length(args) > 0) 
[17:28:21.064]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.064]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.064]             }
[17:28:21.064]             else {
[17:28:21.064]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.064]             }
[17:28:21.064]             {
[17:28:21.064]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.064]                   0L) {
[17:28:21.064]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.064]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.064]                   base::options(opts)
[17:28:21.064]                 }
[17:28:21.064]                 {
[17:28:21.064]                   {
[17:28:21.064]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.064]                     NULL
[17:28:21.064]                   }
[17:28:21.064]                   options(future.plan = NULL)
[17:28:21.064]                   if (is.na(NA_character_)) 
[17:28:21.064]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.064]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.064]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.064]                     .init = FALSE)
[17:28:21.064]                 }
[17:28:21.064]             }
[17:28:21.064]         }
[17:28:21.064]     })
[17:28:21.064]     if (TRUE) {
[17:28:21.064]         base::sink(type = "output", split = FALSE)
[17:28:21.064]         if (TRUE) {
[17:28:21.064]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.064]         }
[17:28:21.064]         else {
[17:28:21.064]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.064]         }
[17:28:21.064]         base::close(...future.stdout)
[17:28:21.064]         ...future.stdout <- NULL
[17:28:21.064]     }
[17:28:21.064]     ...future.result$conditions <- ...future.conditions
[17:28:21.064]     ...future.result$finished <- base::Sys.time()
[17:28:21.064]     ...future.result
[17:28:21.064] }
[17:28:21.069] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:21.069] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:21.070] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:21.070] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:21.070] MultisessionFuture started
[17:28:21.071] - Launch lazy future ... done
[17:28:21.071] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-98726'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x0000026676a3daf8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:28:21.105] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.105] - Validating connection of MultisessionFuture
[17:28:21.105] - received message: FutureResult
[17:28:21.105] - Received FutureResult
[17:28:21.106] - Erased future from FutureRegistry
[17:28:21.106] result() for ClusterFuture ...
[17:28:21.106] - result already collected: FutureResult
[17:28:21.106] result() for ClusterFuture ... done
[17:28:21.106] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: db266b67-3375-aea4-18cf-ad3ddc692f7c
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.106] resolve() on list ...
[17:28:21.107]  recursive: 0
[17:28:21.107]  length: 4
[17:28:21.107] 
[17:28:21.107] Future #1
[17:28:21.107] result() for ClusterFuture ...
[17:28:21.107] - result already collected: FutureResult
[17:28:21.108] result() for ClusterFuture ... done
[17:28:21.108] result() for ClusterFuture ...
[17:28:21.108] - result already collected: FutureResult
[17:28:21.108] result() for ClusterFuture ... done
[17:28:21.108] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:28:21.108] - nx: 4
[17:28:21.108] - relay: TRUE
[17:28:21.109] - stdout: TRUE
[17:28:21.109] - signal: TRUE
[17:28:21.109] - resignal: FALSE
[17:28:21.109] - force: TRUE
[17:28:21.109] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:21.109] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:28:21.110]  - until=1
[17:28:21.110]  - relaying element #1
[17:28:21.110] result() for ClusterFuture ...
[17:28:21.110] - result already collected: FutureResult
[17:28:21.110] result() for ClusterFuture ... done
[17:28:21.110] result() for ClusterFuture ...
[17:28:21.111] - result already collected: FutureResult
[17:28:21.111] result() for ClusterFuture ... done
[17:28:21.111] result() for ClusterFuture ...
[17:28:21.111] - result already collected: FutureResult
[17:28:21.111] result() for ClusterFuture ... done
[17:28:21.111] result() for ClusterFuture ...
[17:28:21.111] - result already collected: FutureResult
[17:28:21.112] result() for ClusterFuture ... done
[17:28:21.112] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:21.112] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:21.112] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[17:28:21.112]  length: 3 (resolved future 1)
[17:28:21.112] Future #2
[17:28:21.113] result() for ClusterFuture ...
[17:28:21.113] - result already collected: FutureResult
[17:28:21.113] result() for ClusterFuture ... done
[17:28:21.113] result() for ClusterFuture ...
[17:28:21.113] - result already collected: FutureResult
[17:28:21.113] result() for ClusterFuture ... done
[17:28:21.114] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:28:21.114] - nx: 4
[17:28:21.114] - relay: TRUE
[17:28:21.114] - stdout: TRUE
[17:28:21.114] - signal: TRUE
[17:28:21.114] - resignal: FALSE
[17:28:21.115] - force: TRUE
[17:28:21.115] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:21.115] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:28:21.115]  - until=2
[17:28:21.115]  - relaying element #2
[17:28:21.115] result() for ClusterFuture ...
[17:28:21.115] - result already collected: FutureResult
[17:28:21.116] result() for ClusterFuture ... done
[17:28:21.116] result() for ClusterFuture ...
[17:28:21.116] - result already collected: FutureResult
[17:28:21.116] result() for ClusterFuture ... done
[17:28:21.116] result() for ClusterFuture ...
[17:28:21.116] - result already collected: FutureResult
[17:28:21.117] result() for ClusterFuture ... done
[17:28:21.117] result() for ClusterFuture ...
[17:28:21.117] - result already collected: FutureResult
[17:28:21.117] result() for ClusterFuture ... done
[17:28:21.117] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:21.117] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:21.118] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:28:21.118]  length: 2 (resolved future 2)
[17:28:21.118] Future #3
[17:28:21.118] result() for ClusterFuture ...
[17:28:21.118] - result already collected: FutureResult
[17:28:21.118] result() for ClusterFuture ... done
[17:28:21.119] result() for ClusterFuture ...
[17:28:21.119] - result already collected: FutureResult
[17:28:21.119] result() for ClusterFuture ... done
[17:28:21.119] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:28:21.119] - nx: 4
[17:28:21.119] - relay: TRUE
[17:28:21.119] - stdout: TRUE
[17:28:21.120] - signal: TRUE
[17:28:21.120] - resignal: FALSE
[17:28:21.120] - force: TRUE
[17:28:21.120] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:21.120] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:28:21.120]  - until=3
[17:28:21.121]  - relaying element #3
[17:28:21.121] result() for ClusterFuture ...
[17:28:21.121] - result already collected: FutureResult
[17:28:21.121] result() for ClusterFuture ... done
[17:28:21.121] result() for ClusterFuture ...
[17:28:21.121] - result already collected: FutureResult
[17:28:21.121] result() for ClusterFuture ... done
[17:28:21.122] result() for ClusterFuture ...
[17:28:21.122] - result already collected: FutureResult
[17:28:21.122] result() for ClusterFuture ... done
[17:28:21.122] result() for ClusterFuture ...
[17:28:21.122] - result already collected: FutureResult
[17:28:21.122] result() for ClusterFuture ... done
[17:28:21.123] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:21.123] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:21.123] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:28:21.123]  length: 1 (resolved future 3)
[17:28:21.123] Future #4
[17:28:21.123] result() for ClusterFuture ...
[17:28:21.124] - result already collected: FutureResult
[17:28:21.124] result() for ClusterFuture ... done
[17:28:21.124] result() for ClusterFuture ...
[17:28:21.124] - result already collected: FutureResult
[17:28:21.124] result() for ClusterFuture ... done
[17:28:21.124] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:28:21.125] - nx: 4
[17:28:21.125] - relay: TRUE
[17:28:21.125] - stdout: TRUE
[17:28:21.125] - signal: TRUE
[17:28:21.125] - resignal: FALSE
[17:28:21.125] - force: TRUE
[17:28:21.125] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:21.126] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:28:21.126]  - until=4
[17:28:21.126]  - relaying element #4
[17:28:21.126] result() for ClusterFuture ...
[17:28:21.126] - result already collected: FutureResult
[17:28:21.126] result() for ClusterFuture ... done
[17:28:21.127] result() for ClusterFuture ...
[17:28:21.127] - result already collected: FutureResult
[17:28:21.127] result() for ClusterFuture ... done
[17:28:21.127] result() for ClusterFuture ...
[17:28:21.127] - result already collected: FutureResult
[17:28:21.127] result() for ClusterFuture ... done
[17:28:21.128] result() for ClusterFuture ...
[17:28:21.128] - result already collected: FutureResult
[17:28:21.128] result() for ClusterFuture ... done
[17:28:21.128] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:21.128] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:21.128] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:28:21.128]  length: 0 (resolved future 4)
[17:28:21.129] Relaying remaining futures
[17:28:21.129] signalConditionsASAP(NULL, pos=0) ...
[17:28:21.129] - nx: 4
[17:28:21.129] - relay: TRUE
[17:28:21.129] - stdout: TRUE
[17:28:21.129] - signal: TRUE
[17:28:21.129] - resignal: FALSE
[17:28:21.130] - force: TRUE
[17:28:21.130] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:21.130] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:28:21.130] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:21.130] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:28:21.131] signalConditionsASAP(NULL, pos=0) ... done
[17:28:21.131] resolve() on list ... DONE
[17:28:21.131] result() for ClusterFuture ...
[17:28:21.131] - result already collected: FutureResult
[17:28:21.131] result() for ClusterFuture ... done
[17:28:21.131] result() for ClusterFuture ...
[17:28:21.131] - result already collected: FutureResult
[17:28:21.132] result() for ClusterFuture ... done
[17:28:21.132] result() for ClusterFuture ...
[17:28:21.132] - result already collected: FutureResult
[17:28:21.132] result() for ClusterFuture ... done
[17:28:21.132] result() for ClusterFuture ...
[17:28:21.132] - result already collected: FutureResult
[17:28:21.133] result() for ClusterFuture ... done
[17:28:21.133] result() for ClusterFuture ...
[17:28:21.133] - result already collected: FutureResult
[17:28:21.133] result() for ClusterFuture ... done
[17:28:21.133] result() for ClusterFuture ...
[17:28:21.133] - result already collected: FutureResult
[17:28:21.133] result() for ClusterFuture ... done
[17:28:21.134] result() for ClusterFuture ...
[17:28:21.134] - result already collected: FutureResult
[17:28:21.134] result() for ClusterFuture ... done
[17:28:21.134] result() for ClusterFuture ...
[17:28:21.134] - result already collected: FutureResult
[17:28:21.135] result() for ClusterFuture ... done
[[1]]
[1] 0

[[2]]
[1] 0

[[3]]
[1] 1

[[4]]
[1] 0

[17:28:21.135] getGlobalsAndPackages() ...
[17:28:21.135] Searching for globals...
[17:28:21.136] - globals found: [3] '{', 'sample', 'x'
[17:28:21.137] Searching for globals ... DONE
[17:28:21.137] Resolving globals: FALSE
[17:28:21.137] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.138] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.138] - globals: [1] 'x'
[17:28:21.138] 
[17:28:21.138] getGlobalsAndPackages() ... DONE
[17:28:21.139] run() for 'Future' ...
[17:28:21.139] - state: 'created'
[17:28:21.139] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.153] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.153] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.153]   - Field: 'node'
[17:28:21.153]   - Field: 'label'
[17:28:21.153]   - Field: 'local'
[17:28:21.153]   - Field: 'owner'
[17:28:21.154]   - Field: 'envir'
[17:28:21.154]   - Field: 'workers'
[17:28:21.154]   - Field: 'packages'
[17:28:21.154]   - Field: 'gc'
[17:28:21.154]   - Field: 'conditions'
[17:28:21.155]   - Field: 'persistent'
[17:28:21.155]   - Field: 'expr'
[17:28:21.155]   - Field: 'uuid'
[17:28:21.155]   - Field: 'seed'
[17:28:21.155]   - Field: 'version'
[17:28:21.155]   - Field: 'result'
[17:28:21.156]   - Field: 'asynchronous'
[17:28:21.156]   - Field: 'calls'
[17:28:21.156]   - Field: 'globals'
[17:28:21.156]   - Field: 'stdout'
[17:28:21.156]   - Field: 'earlySignal'
[17:28:21.156]   - Field: 'lazy'
[17:28:21.157]   - Field: 'state'
[17:28:21.157] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.157] - Launch lazy future ...
[17:28:21.157] Packages needed by the future expression (n = 0): <none>
[17:28:21.158] Packages needed by future strategies (n = 0): <none>
[17:28:21.158] {
[17:28:21.158]     {
[17:28:21.158]         {
[17:28:21.158]             ...future.startTime <- base::Sys.time()
[17:28:21.158]             {
[17:28:21.158]                 {
[17:28:21.158]                   {
[17:28:21.158]                     {
[17:28:21.158]                       {
[17:28:21.158]                         base::local({
[17:28:21.158]                           has_future <- base::requireNamespace("future", 
[17:28:21.158]                             quietly = TRUE)
[17:28:21.158]                           if (has_future) {
[17:28:21.158]                             ns <- base::getNamespace("future")
[17:28:21.158]                             version <- ns[[".package"]][["version"]]
[17:28:21.158]                             if (is.null(version)) 
[17:28:21.158]                               version <- utils::packageVersion("future")
[17:28:21.158]                           }
[17:28:21.158]                           else {
[17:28:21.158]                             version <- NULL
[17:28:21.158]                           }
[17:28:21.158]                           if (!has_future || version < "1.8.0") {
[17:28:21.158]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.158]                               "", base::R.version$version.string), 
[17:28:21.158]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:21.158]                                 base::R.version$platform, 8 * 
[17:28:21.158]                                   base::.Machine$sizeof.pointer), 
[17:28:21.158]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.158]                                 "release", "version")], collapse = " "), 
[17:28:21.158]                               hostname = base::Sys.info()[["nodename"]])
[17:28:21.158]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.158]                               info)
[17:28:21.158]                             info <- base::paste(info, collapse = "; ")
[17:28:21.158]                             if (!has_future) {
[17:28:21.158]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.158]                                 info)
[17:28:21.158]                             }
[17:28:21.158]                             else {
[17:28:21.158]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.158]                                 info, version)
[17:28:21.158]                             }
[17:28:21.158]                             base::stop(msg)
[17:28:21.158]                           }
[17:28:21.158]                         })
[17:28:21.158]                       }
[17:28:21.158]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.158]                       base::options(mc.cores = 1L)
[17:28:21.158]                     }
[17:28:21.158]                     ...future.strategy.old <- future::plan("list")
[17:28:21.158]                     options(future.plan = NULL)
[17:28:21.158]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.158]                     future::plan("default", .cleanup = FALSE, 
[17:28:21.158]                       .init = FALSE)
[17:28:21.158]                   }
[17:28:21.158]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:28:21.158]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:28:21.158]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:28:21.158]                 }
[17:28:21.158]                 ...future.workdir <- getwd()
[17:28:21.158]             }
[17:28:21.158]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.158]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.158]         }
[17:28:21.158]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.158]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.158]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.158]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.158]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.158]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.158]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.158]             base::names(...future.oldOptions))
[17:28:21.158]     }
[17:28:21.158]     if (FALSE) {
[17:28:21.158]     }
[17:28:21.158]     else {
[17:28:21.158]         if (TRUE) {
[17:28:21.158]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.158]                 open = "w")
[17:28:21.158]         }
[17:28:21.158]         else {
[17:28:21.158]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.158]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.158]         }
[17:28:21.158]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.158]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.158]             base::sink(type = "output", split = FALSE)
[17:28:21.158]             base::close(...future.stdout)
[17:28:21.158]         }, add = TRUE)
[17:28:21.158]     }
[17:28:21.158]     ...future.frame <- base::sys.nframe()
[17:28:21.158]     ...future.conditions <- base::list()
[17:28:21.158]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.158]     if (FALSE) {
[17:28:21.158]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.158]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.158]     }
[17:28:21.158]     ...future.result <- base::tryCatch({
[17:28:21.158]         base::withCallingHandlers({
[17:28:21.158]             ...future.value <- base::withVisible(base::local({
[17:28:21.158]                 ...future.makeSendCondition <- base::local({
[17:28:21.158]                   sendCondition <- NULL
[17:28:21.158]                   function(frame = 1L) {
[17:28:21.158]                     if (is.function(sendCondition)) 
[17:28:21.158]                       return(sendCondition)
[17:28:21.158]                     ns <- getNamespace("parallel")
[17:28:21.158]                     if (exists("sendData", mode = "function", 
[17:28:21.158]                       envir = ns)) {
[17:28:21.158]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.158]                         envir = ns)
[17:28:21.158]                       envir <- sys.frame(frame)
[17:28:21.158]                       master <- NULL
[17:28:21.158]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.158]                         !identical(envir, emptyenv())) {
[17:28:21.158]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.158]                           inherits = FALSE)) {
[17:28:21.158]                           master <- get("master", mode = "list", 
[17:28:21.158]                             envir = envir, inherits = FALSE)
[17:28:21.158]                           if (inherits(master, c("SOCKnode", 
[17:28:21.158]                             "SOCK0node"))) {
[17:28:21.158]                             sendCondition <<- function(cond) {
[17:28:21.158]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.158]                                 success = TRUE)
[17:28:21.158]                               parallel_sendData(master, data)
[17:28:21.158]                             }
[17:28:21.158]                             return(sendCondition)
[17:28:21.158]                           }
[17:28:21.158]                         }
[17:28:21.158]                         frame <- frame + 1L
[17:28:21.158]                         envir <- sys.frame(frame)
[17:28:21.158]                       }
[17:28:21.158]                     }
[17:28:21.158]                     sendCondition <<- function(cond) NULL
[17:28:21.158]                   }
[17:28:21.158]                 })
[17:28:21.158]                 withCallingHandlers({
[17:28:21.158]                   {
[17:28:21.158]                     sample(x, size = 1L)
[17:28:21.158]                   }
[17:28:21.158]                 }, immediateCondition = function(cond) {
[17:28:21.158]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.158]                   sendCondition(cond)
[17:28:21.158]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.158]                   {
[17:28:21.158]                     inherits <- base::inherits
[17:28:21.158]                     invokeRestart <- base::invokeRestart
[17:28:21.158]                     is.null <- base::is.null
[17:28:21.158]                     muffled <- FALSE
[17:28:21.158]                     if (inherits(cond, "message")) {
[17:28:21.158]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.158]                       if (muffled) 
[17:28:21.158]                         invokeRestart("muffleMessage")
[17:28:21.158]                     }
[17:28:21.158]                     else if (inherits(cond, "warning")) {
[17:28:21.158]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.158]                       if (muffled) 
[17:28:21.158]                         invokeRestart("muffleWarning")
[17:28:21.158]                     }
[17:28:21.158]                     else if (inherits(cond, "condition")) {
[17:28:21.158]                       if (!is.null(pattern)) {
[17:28:21.158]                         computeRestarts <- base::computeRestarts
[17:28:21.158]                         grepl <- base::grepl
[17:28:21.158]                         restarts <- computeRestarts(cond)
[17:28:21.158]                         for (restart in restarts) {
[17:28:21.158]                           name <- restart$name
[17:28:21.158]                           if (is.null(name)) 
[17:28:21.158]                             next
[17:28:21.158]                           if (!grepl(pattern, name)) 
[17:28:21.158]                             next
[17:28:21.158]                           invokeRestart(restart)
[17:28:21.158]                           muffled <- TRUE
[17:28:21.158]                           break
[17:28:21.158]                         }
[17:28:21.158]                       }
[17:28:21.158]                     }
[17:28:21.158]                     invisible(muffled)
[17:28:21.158]                   }
[17:28:21.158]                   muffleCondition(cond)
[17:28:21.158]                 })
[17:28:21.158]             }))
[17:28:21.158]             future::FutureResult(value = ...future.value$value, 
[17:28:21.158]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.158]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.158]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.158]                     ...future.globalenv.names))
[17:28:21.158]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.158]         }, condition = base::local({
[17:28:21.158]             c <- base::c
[17:28:21.158]             inherits <- base::inherits
[17:28:21.158]             invokeRestart <- base::invokeRestart
[17:28:21.158]             length <- base::length
[17:28:21.158]             list <- base::list
[17:28:21.158]             seq.int <- base::seq.int
[17:28:21.158]             signalCondition <- base::signalCondition
[17:28:21.158]             sys.calls <- base::sys.calls
[17:28:21.158]             `[[` <- base::`[[`
[17:28:21.158]             `+` <- base::`+`
[17:28:21.158]             `<<-` <- base::`<<-`
[17:28:21.158]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.158]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.158]                   3L)]
[17:28:21.158]             }
[17:28:21.158]             function(cond) {
[17:28:21.158]                 is_error <- inherits(cond, "error")
[17:28:21.158]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.158]                   NULL)
[17:28:21.158]                 if (is_error) {
[17:28:21.158]                   sessionInformation <- function() {
[17:28:21.158]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.158]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.158]                       search = base::search(), system = base::Sys.info())
[17:28:21.158]                   }
[17:28:21.158]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.158]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.158]                     cond$call), session = sessionInformation(), 
[17:28:21.158]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.158]                   signalCondition(cond)
[17:28:21.158]                 }
[17:28:21.158]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.158]                 "immediateCondition"))) {
[17:28:21.158]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.158]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.158]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.158]                   if (TRUE && !signal) {
[17:28:21.158]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.158]                     {
[17:28:21.158]                       inherits <- base::inherits
[17:28:21.158]                       invokeRestart <- base::invokeRestart
[17:28:21.158]                       is.null <- base::is.null
[17:28:21.158]                       muffled <- FALSE
[17:28:21.158]                       if (inherits(cond, "message")) {
[17:28:21.158]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.158]                         if (muffled) 
[17:28:21.158]                           invokeRestart("muffleMessage")
[17:28:21.158]                       }
[17:28:21.158]                       else if (inherits(cond, "warning")) {
[17:28:21.158]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.158]                         if (muffled) 
[17:28:21.158]                           invokeRestart("muffleWarning")
[17:28:21.158]                       }
[17:28:21.158]                       else if (inherits(cond, "condition")) {
[17:28:21.158]                         if (!is.null(pattern)) {
[17:28:21.158]                           computeRestarts <- base::computeRestarts
[17:28:21.158]                           grepl <- base::grepl
[17:28:21.158]                           restarts <- computeRestarts(cond)
[17:28:21.158]                           for (restart in restarts) {
[17:28:21.158]                             name <- restart$name
[17:28:21.158]                             if (is.null(name)) 
[17:28:21.158]                               next
[17:28:21.158]                             if (!grepl(pattern, name)) 
[17:28:21.158]                               next
[17:28:21.158]                             invokeRestart(restart)
[17:28:21.158]                             muffled <- TRUE
[17:28:21.158]                             break
[17:28:21.158]                           }
[17:28:21.158]                         }
[17:28:21.158]                       }
[17:28:21.158]                       invisible(muffled)
[17:28:21.158]                     }
[17:28:21.158]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.158]                   }
[17:28:21.158]                 }
[17:28:21.158]                 else {
[17:28:21.158]                   if (TRUE) {
[17:28:21.158]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.158]                     {
[17:28:21.158]                       inherits <- base::inherits
[17:28:21.158]                       invokeRestart <- base::invokeRestart
[17:28:21.158]                       is.null <- base::is.null
[17:28:21.158]                       muffled <- FALSE
[17:28:21.158]                       if (inherits(cond, "message")) {
[17:28:21.158]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.158]                         if (muffled) 
[17:28:21.158]                           invokeRestart("muffleMessage")
[17:28:21.158]                       }
[17:28:21.158]                       else if (inherits(cond, "warning")) {
[17:28:21.158]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.158]                         if (muffled) 
[17:28:21.158]                           invokeRestart("muffleWarning")
[17:28:21.158]                       }
[17:28:21.158]                       else if (inherits(cond, "condition")) {
[17:28:21.158]                         if (!is.null(pattern)) {
[17:28:21.158]                           computeRestarts <- base::computeRestarts
[17:28:21.158]                           grepl <- base::grepl
[17:28:21.158]                           restarts <- computeRestarts(cond)
[17:28:21.158]                           for (restart in restarts) {
[17:28:21.158]                             name <- restart$name
[17:28:21.158]                             if (is.null(name)) 
[17:28:21.158]                               next
[17:28:21.158]                             if (!grepl(pattern, name)) 
[17:28:21.158]                               next
[17:28:21.158]                             invokeRestart(restart)
[17:28:21.158]                             muffled <- TRUE
[17:28:21.158]                             break
[17:28:21.158]                           }
[17:28:21.158]                         }
[17:28:21.158]                       }
[17:28:21.158]                       invisible(muffled)
[17:28:21.158]                     }
[17:28:21.158]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.158]                   }
[17:28:21.158]                 }
[17:28:21.158]             }
[17:28:21.158]         }))
[17:28:21.158]     }, error = function(ex) {
[17:28:21.158]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.158]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.158]                 ...future.rng), started = ...future.startTime, 
[17:28:21.158]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.158]             version = "1.8"), class = "FutureResult")
[17:28:21.158]     }, finally = {
[17:28:21.158]         if (!identical(...future.workdir, getwd())) 
[17:28:21.158]             setwd(...future.workdir)
[17:28:21.158]         {
[17:28:21.158]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.158]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.158]             }
[17:28:21.158]             base::options(...future.oldOptions)
[17:28:21.158]             if (.Platform$OS.type == "windows") {
[17:28:21.158]                 old_names <- names(...future.oldEnvVars)
[17:28:21.158]                 envs <- base::Sys.getenv()
[17:28:21.158]                 names <- names(envs)
[17:28:21.158]                 common <- intersect(names, old_names)
[17:28:21.158]                 added <- setdiff(names, old_names)
[17:28:21.158]                 removed <- setdiff(old_names, names)
[17:28:21.158]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.158]                   envs[common]]
[17:28:21.158]                 NAMES <- toupper(changed)
[17:28:21.158]                 args <- list()
[17:28:21.158]                 for (kk in seq_along(NAMES)) {
[17:28:21.158]                   name <- changed[[kk]]
[17:28:21.158]                   NAME <- NAMES[[kk]]
[17:28:21.158]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.158]                     next
[17:28:21.158]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.158]                 }
[17:28:21.158]                 NAMES <- toupper(added)
[17:28:21.158]                 for (kk in seq_along(NAMES)) {
[17:28:21.158]                   name <- added[[kk]]
[17:28:21.158]                   NAME <- NAMES[[kk]]
[17:28:21.158]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.158]                     next
[17:28:21.158]                   args[[name]] <- ""
[17:28:21.158]                 }
[17:28:21.158]                 NAMES <- toupper(removed)
[17:28:21.158]                 for (kk in seq_along(NAMES)) {
[17:28:21.158]                   name <- removed[[kk]]
[17:28:21.158]                   NAME <- NAMES[[kk]]
[17:28:21.158]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.158]                     next
[17:28:21.158]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.158]                 }
[17:28:21.158]                 if (length(args) > 0) 
[17:28:21.158]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.158]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.158]             }
[17:28:21.158]             else {
[17:28:21.158]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.158]             }
[17:28:21.158]             {
[17:28:21.158]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.158]                   0L) {
[17:28:21.158]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.158]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.158]                   base::options(opts)
[17:28:21.158]                 }
[17:28:21.158]                 {
[17:28:21.158]                   {
[17:28:21.158]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.158]                     NULL
[17:28:21.158]                   }
[17:28:21.158]                   options(future.plan = NULL)
[17:28:21.158]                   if (is.na(NA_character_)) 
[17:28:21.158]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.158]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.158]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.158]                     .init = FALSE)
[17:28:21.158]                 }
[17:28:21.158]             }
[17:28:21.158]         }
[17:28:21.158]     })
[17:28:21.158]     if (TRUE) {
[17:28:21.158]         base::sink(type = "output", split = FALSE)
[17:28:21.158]         if (TRUE) {
[17:28:21.158]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.158]         }
[17:28:21.158]         else {
[17:28:21.158]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.158]         }
[17:28:21.158]         base::close(...future.stdout)
[17:28:21.158]         ...future.stdout <- NULL
[17:28:21.158]     }
[17:28:21.158]     ...future.result$conditions <- ...future.conditions
[17:28:21.158]     ...future.result$finished <- base::Sys.time()
[17:28:21.158]     ...future.result
[17:28:21.158] }
[17:28:21.163] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:21.163] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:21.164] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:21.164] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:21.165] MultisessionFuture started
[17:28:21.165] - Launch lazy future ... done
[17:28:21.165] run() for 'MultisessionFuture' ... done
[17:28:21.165] getGlobalsAndPackages() ...
[17:28:21.166] Searching for globals...
[17:28:21.167] - globals found: [3] '{', 'sample', 'x'
[17:28:21.167] Searching for globals ... DONE
[17:28:21.167] Resolving globals: FALSE
[17:28:21.168] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.168] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.168] - globals: [1] 'x'
[17:28:21.168] 
[17:28:21.169] getGlobalsAndPackages() ... DONE
[17:28:21.169] run() for 'Future' ...
[17:28:21.169] - state: 'created'
[17:28:21.169] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.183] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.183] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.183]   - Field: 'node'
[17:28:21.183]   - Field: 'label'
[17:28:21.183]   - Field: 'local'
[17:28:21.184]   - Field: 'owner'
[17:28:21.184]   - Field: 'envir'
[17:28:21.184]   - Field: 'workers'
[17:28:21.184]   - Field: 'packages'
[17:28:21.184]   - Field: 'gc'
[17:28:21.184]   - Field: 'conditions'
[17:28:21.185]   - Field: 'persistent'
[17:28:21.185]   - Field: 'expr'
[17:28:21.185]   - Field: 'uuid'
[17:28:21.185]   - Field: 'seed'
[17:28:21.185]   - Field: 'version'
[17:28:21.186]   - Field: 'result'
[17:28:21.186]   - Field: 'asynchronous'
[17:28:21.186]   - Field: 'calls'
[17:28:21.186]   - Field: 'globals'
[17:28:21.186]   - Field: 'stdout'
[17:28:21.187]   - Field: 'earlySignal'
[17:28:21.187]   - Field: 'lazy'
[17:28:21.187]   - Field: 'state'
[17:28:21.187] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.187] - Launch lazy future ...
[17:28:21.188] Packages needed by the future expression (n = 0): <none>
[17:28:21.188] Packages needed by future strategies (n = 0): <none>
[17:28:21.188] {
[17:28:21.188]     {
[17:28:21.188]         {
[17:28:21.188]             ...future.startTime <- base::Sys.time()
[17:28:21.188]             {
[17:28:21.188]                 {
[17:28:21.188]                   {
[17:28:21.188]                     {
[17:28:21.188]                       {
[17:28:21.188]                         base::local({
[17:28:21.188]                           has_future <- base::requireNamespace("future", 
[17:28:21.188]                             quietly = TRUE)
[17:28:21.188]                           if (has_future) {
[17:28:21.188]                             ns <- base::getNamespace("future")
[17:28:21.188]                             version <- ns[[".package"]][["version"]]
[17:28:21.188]                             if (is.null(version)) 
[17:28:21.188]                               version <- utils::packageVersion("future")
[17:28:21.188]                           }
[17:28:21.188]                           else {
[17:28:21.188]                             version <- NULL
[17:28:21.188]                           }
[17:28:21.188]                           if (!has_future || version < "1.8.0") {
[17:28:21.188]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.188]                               "", base::R.version$version.string), 
[17:28:21.188]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:21.188]                                 base::R.version$platform, 8 * 
[17:28:21.188]                                   base::.Machine$sizeof.pointer), 
[17:28:21.188]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.188]                                 "release", "version")], collapse = " "), 
[17:28:21.188]                               hostname = base::Sys.info()[["nodename"]])
[17:28:21.188]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.188]                               info)
[17:28:21.188]                             info <- base::paste(info, collapse = "; ")
[17:28:21.188]                             if (!has_future) {
[17:28:21.188]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.188]                                 info)
[17:28:21.188]                             }
[17:28:21.188]                             else {
[17:28:21.188]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.188]                                 info, version)
[17:28:21.188]                             }
[17:28:21.188]                             base::stop(msg)
[17:28:21.188]                           }
[17:28:21.188]                         })
[17:28:21.188]                       }
[17:28:21.188]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.188]                       base::options(mc.cores = 1L)
[17:28:21.188]                     }
[17:28:21.188]                     ...future.strategy.old <- future::plan("list")
[17:28:21.188]                     options(future.plan = NULL)
[17:28:21.188]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.188]                     future::plan("default", .cleanup = FALSE, 
[17:28:21.188]                       .init = FALSE)
[17:28:21.188]                   }
[17:28:21.188]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:28:21.188]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:28:21.188]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:28:21.188]                 }
[17:28:21.188]                 ...future.workdir <- getwd()
[17:28:21.188]             }
[17:28:21.188]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.188]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.188]         }
[17:28:21.188]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.188]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.188]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.188]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.188]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.188]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.188]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.188]             base::names(...future.oldOptions))
[17:28:21.188]     }
[17:28:21.188]     if (FALSE) {
[17:28:21.188]     }
[17:28:21.188]     else {
[17:28:21.188]         if (TRUE) {
[17:28:21.188]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.188]                 open = "w")
[17:28:21.188]         }
[17:28:21.188]         else {
[17:28:21.188]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.188]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.188]         }
[17:28:21.188]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.188]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.188]             base::sink(type = "output", split = FALSE)
[17:28:21.188]             base::close(...future.stdout)
[17:28:21.188]         }, add = TRUE)
[17:28:21.188]     }
[17:28:21.188]     ...future.frame <- base::sys.nframe()
[17:28:21.188]     ...future.conditions <- base::list()
[17:28:21.188]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.188]     if (FALSE) {
[17:28:21.188]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.188]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.188]     }
[17:28:21.188]     ...future.result <- base::tryCatch({
[17:28:21.188]         base::withCallingHandlers({
[17:28:21.188]             ...future.value <- base::withVisible(base::local({
[17:28:21.188]                 ...future.makeSendCondition <- base::local({
[17:28:21.188]                   sendCondition <- NULL
[17:28:21.188]                   function(frame = 1L) {
[17:28:21.188]                     if (is.function(sendCondition)) 
[17:28:21.188]                       return(sendCondition)
[17:28:21.188]                     ns <- getNamespace("parallel")
[17:28:21.188]                     if (exists("sendData", mode = "function", 
[17:28:21.188]                       envir = ns)) {
[17:28:21.188]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.188]                         envir = ns)
[17:28:21.188]                       envir <- sys.frame(frame)
[17:28:21.188]                       master <- NULL
[17:28:21.188]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.188]                         !identical(envir, emptyenv())) {
[17:28:21.188]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.188]                           inherits = FALSE)) {
[17:28:21.188]                           master <- get("master", mode = "list", 
[17:28:21.188]                             envir = envir, inherits = FALSE)
[17:28:21.188]                           if (inherits(master, c("SOCKnode", 
[17:28:21.188]                             "SOCK0node"))) {
[17:28:21.188]                             sendCondition <<- function(cond) {
[17:28:21.188]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.188]                                 success = TRUE)
[17:28:21.188]                               parallel_sendData(master, data)
[17:28:21.188]                             }
[17:28:21.188]                             return(sendCondition)
[17:28:21.188]                           }
[17:28:21.188]                         }
[17:28:21.188]                         frame <- frame + 1L
[17:28:21.188]                         envir <- sys.frame(frame)
[17:28:21.188]                       }
[17:28:21.188]                     }
[17:28:21.188]                     sendCondition <<- function(cond) NULL
[17:28:21.188]                   }
[17:28:21.188]                 })
[17:28:21.188]                 withCallingHandlers({
[17:28:21.188]                   {
[17:28:21.188]                     sample(x, size = 1L)
[17:28:21.188]                   }
[17:28:21.188]                 }, immediateCondition = function(cond) {
[17:28:21.188]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.188]                   sendCondition(cond)
[17:28:21.188]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.188]                   {
[17:28:21.188]                     inherits <- base::inherits
[17:28:21.188]                     invokeRestart <- base::invokeRestart
[17:28:21.188]                     is.null <- base::is.null
[17:28:21.188]                     muffled <- FALSE
[17:28:21.188]                     if (inherits(cond, "message")) {
[17:28:21.188]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.188]                       if (muffled) 
[17:28:21.188]                         invokeRestart("muffleMessage")
[17:28:21.188]                     }
[17:28:21.188]                     else if (inherits(cond, "warning")) {
[17:28:21.188]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.188]                       if (muffled) 
[17:28:21.188]                         invokeRestart("muffleWarning")
[17:28:21.188]                     }
[17:28:21.188]                     else if (inherits(cond, "condition")) {
[17:28:21.188]                       if (!is.null(pattern)) {
[17:28:21.188]                         computeRestarts <- base::computeRestarts
[17:28:21.188]                         grepl <- base::grepl
[17:28:21.188]                         restarts <- computeRestarts(cond)
[17:28:21.188]                         for (restart in restarts) {
[17:28:21.188]                           name <- restart$name
[17:28:21.188]                           if (is.null(name)) 
[17:28:21.188]                             next
[17:28:21.188]                           if (!grepl(pattern, name)) 
[17:28:21.188]                             next
[17:28:21.188]                           invokeRestart(restart)
[17:28:21.188]                           muffled <- TRUE
[17:28:21.188]                           break
[17:28:21.188]                         }
[17:28:21.188]                       }
[17:28:21.188]                     }
[17:28:21.188]                     invisible(muffled)
[17:28:21.188]                   }
[17:28:21.188]                   muffleCondition(cond)
[17:28:21.188]                 })
[17:28:21.188]             }))
[17:28:21.188]             future::FutureResult(value = ...future.value$value, 
[17:28:21.188]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.188]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.188]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.188]                     ...future.globalenv.names))
[17:28:21.188]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.188]         }, condition = base::local({
[17:28:21.188]             c <- base::c
[17:28:21.188]             inherits <- base::inherits
[17:28:21.188]             invokeRestart <- base::invokeRestart
[17:28:21.188]             length <- base::length
[17:28:21.188]             list <- base::list
[17:28:21.188]             seq.int <- base::seq.int
[17:28:21.188]             signalCondition <- base::signalCondition
[17:28:21.188]             sys.calls <- base::sys.calls
[17:28:21.188]             `[[` <- base::`[[`
[17:28:21.188]             `+` <- base::`+`
[17:28:21.188]             `<<-` <- base::`<<-`
[17:28:21.188]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.188]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.188]                   3L)]
[17:28:21.188]             }
[17:28:21.188]             function(cond) {
[17:28:21.188]                 is_error <- inherits(cond, "error")
[17:28:21.188]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.188]                   NULL)
[17:28:21.188]                 if (is_error) {
[17:28:21.188]                   sessionInformation <- function() {
[17:28:21.188]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.188]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.188]                       search = base::search(), system = base::Sys.info())
[17:28:21.188]                   }
[17:28:21.188]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.188]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.188]                     cond$call), session = sessionInformation(), 
[17:28:21.188]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.188]                   signalCondition(cond)
[17:28:21.188]                 }
[17:28:21.188]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.188]                 "immediateCondition"))) {
[17:28:21.188]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.188]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.188]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.188]                   if (TRUE && !signal) {
[17:28:21.188]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.188]                     {
[17:28:21.188]                       inherits <- base::inherits
[17:28:21.188]                       invokeRestart <- base::invokeRestart
[17:28:21.188]                       is.null <- base::is.null
[17:28:21.188]                       muffled <- FALSE
[17:28:21.188]                       if (inherits(cond, "message")) {
[17:28:21.188]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.188]                         if (muffled) 
[17:28:21.188]                           invokeRestart("muffleMessage")
[17:28:21.188]                       }
[17:28:21.188]                       else if (inherits(cond, "warning")) {
[17:28:21.188]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.188]                         if (muffled) 
[17:28:21.188]                           invokeRestart("muffleWarning")
[17:28:21.188]                       }
[17:28:21.188]                       else if (inherits(cond, "condition")) {
[17:28:21.188]                         if (!is.null(pattern)) {
[17:28:21.188]                           computeRestarts <- base::computeRestarts
[17:28:21.188]                           grepl <- base::grepl
[17:28:21.188]                           restarts <- computeRestarts(cond)
[17:28:21.188]                           for (restart in restarts) {
[17:28:21.188]                             name <- restart$name
[17:28:21.188]                             if (is.null(name)) 
[17:28:21.188]                               next
[17:28:21.188]                             if (!grepl(pattern, name)) 
[17:28:21.188]                               next
[17:28:21.188]                             invokeRestart(restart)
[17:28:21.188]                             muffled <- TRUE
[17:28:21.188]                             break
[17:28:21.188]                           }
[17:28:21.188]                         }
[17:28:21.188]                       }
[17:28:21.188]                       invisible(muffled)
[17:28:21.188]                     }
[17:28:21.188]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.188]                   }
[17:28:21.188]                 }
[17:28:21.188]                 else {
[17:28:21.188]                   if (TRUE) {
[17:28:21.188]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.188]                     {
[17:28:21.188]                       inherits <- base::inherits
[17:28:21.188]                       invokeRestart <- base::invokeRestart
[17:28:21.188]                       is.null <- base::is.null
[17:28:21.188]                       muffled <- FALSE
[17:28:21.188]                       if (inherits(cond, "message")) {
[17:28:21.188]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.188]                         if (muffled) 
[17:28:21.188]                           invokeRestart("muffleMessage")
[17:28:21.188]                       }
[17:28:21.188]                       else if (inherits(cond, "warning")) {
[17:28:21.188]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.188]                         if (muffled) 
[17:28:21.188]                           invokeRestart("muffleWarning")
[17:28:21.188]                       }
[17:28:21.188]                       else if (inherits(cond, "condition")) {
[17:28:21.188]                         if (!is.null(pattern)) {
[17:28:21.188]                           computeRestarts <- base::computeRestarts
[17:28:21.188]                           grepl <- base::grepl
[17:28:21.188]                           restarts <- computeRestarts(cond)
[17:28:21.188]                           for (restart in restarts) {
[17:28:21.188]                             name <- restart$name
[17:28:21.188]                             if (is.null(name)) 
[17:28:21.188]                               next
[17:28:21.188]                             if (!grepl(pattern, name)) 
[17:28:21.188]                               next
[17:28:21.188]                             invokeRestart(restart)
[17:28:21.188]                             muffled <- TRUE
[17:28:21.188]                             break
[17:28:21.188]                           }
[17:28:21.188]                         }
[17:28:21.188]                       }
[17:28:21.188]                       invisible(muffled)
[17:28:21.188]                     }
[17:28:21.188]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.188]                   }
[17:28:21.188]                 }
[17:28:21.188]             }
[17:28:21.188]         }))
[17:28:21.188]     }, error = function(ex) {
[17:28:21.188]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.188]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.188]                 ...future.rng), started = ...future.startTime, 
[17:28:21.188]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.188]             version = "1.8"), class = "FutureResult")
[17:28:21.188]     }, finally = {
[17:28:21.188]         if (!identical(...future.workdir, getwd())) 
[17:28:21.188]             setwd(...future.workdir)
[17:28:21.188]         {
[17:28:21.188]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.188]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.188]             }
[17:28:21.188]             base::options(...future.oldOptions)
[17:28:21.188]             if (.Platform$OS.type == "windows") {
[17:28:21.188]                 old_names <- names(...future.oldEnvVars)
[17:28:21.188]                 envs <- base::Sys.getenv()
[17:28:21.188]                 names <- names(envs)
[17:28:21.188]                 common <- intersect(names, old_names)
[17:28:21.188]                 added <- setdiff(names, old_names)
[17:28:21.188]                 removed <- setdiff(old_names, names)
[17:28:21.188]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.188]                   envs[common]]
[17:28:21.188]                 NAMES <- toupper(changed)
[17:28:21.188]                 args <- list()
[17:28:21.188]                 for (kk in seq_along(NAMES)) {
[17:28:21.188]                   name <- changed[[kk]]
[17:28:21.188]                   NAME <- NAMES[[kk]]
[17:28:21.188]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.188]                     next
[17:28:21.188]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.188]                 }
[17:28:21.188]                 NAMES <- toupper(added)
[17:28:21.188]                 for (kk in seq_along(NAMES)) {
[17:28:21.188]                   name <- added[[kk]]
[17:28:21.188]                   NAME <- NAMES[[kk]]
[17:28:21.188]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.188]                     next
[17:28:21.188]                   args[[name]] <- ""
[17:28:21.188]                 }
[17:28:21.188]                 NAMES <- toupper(removed)
[17:28:21.188]                 for (kk in seq_along(NAMES)) {
[17:28:21.188]                   name <- removed[[kk]]
[17:28:21.188]                   NAME <- NAMES[[kk]]
[17:28:21.188]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.188]                     next
[17:28:21.188]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.188]                 }
[17:28:21.188]                 if (length(args) > 0) 
[17:28:21.188]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.188]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.188]             }
[17:28:21.188]             else {
[17:28:21.188]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.188]             }
[17:28:21.188]             {
[17:28:21.188]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.188]                   0L) {
[17:28:21.188]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.188]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.188]                   base::options(opts)
[17:28:21.188]                 }
[17:28:21.188]                 {
[17:28:21.188]                   {
[17:28:21.188]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.188]                     NULL
[17:28:21.188]                   }
[17:28:21.188]                   options(future.plan = NULL)
[17:28:21.188]                   if (is.na(NA_character_)) 
[17:28:21.188]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.188]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.188]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.188]                     .init = FALSE)
[17:28:21.188]                 }
[17:28:21.188]             }
[17:28:21.188]         }
[17:28:21.188]     })
[17:28:21.188]     if (TRUE) {
[17:28:21.188]         base::sink(type = "output", split = FALSE)
[17:28:21.188]         if (TRUE) {
[17:28:21.188]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.188]         }
[17:28:21.188]         else {
[17:28:21.188]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.188]         }
[17:28:21.188]         base::close(...future.stdout)
[17:28:21.188]         ...future.stdout <- NULL
[17:28:21.188]     }
[17:28:21.188]     ...future.result$conditions <- ...future.conditions
[17:28:21.188]     ...future.result$finished <- base::Sys.time()
[17:28:21.188]     ...future.result
[17:28:21.188] }
[17:28:21.194] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:21.194] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:21.194] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:21.194] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:21.195] MultisessionFuture started
[17:28:21.195] - Launch lazy future ... done
[17:28:21.195] run() for 'MultisessionFuture' ... done
[17:28:21.196] getGlobalsAndPackages() ...
[17:28:21.196] Searching for globals...
[17:28:21.197] - globals found: [3] '{', 'sample', 'x'
[17:28:21.197] Searching for globals ... DONE
[17:28:21.198] Resolving globals: FALSE
[17:28:21.198] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.199] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.199] - globals: [1] 'x'
[17:28:21.199] 
[17:28:21.199] getGlobalsAndPackages() ... DONE
[17:28:21.199] run() for 'Future' ...
[17:28:21.200] - state: 'created'
[17:28:21.200] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.213] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.213] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.214]   - Field: 'node'
[17:28:21.214]   - Field: 'label'
[17:28:21.214]   - Field: 'local'
[17:28:21.214]   - Field: 'owner'
[17:28:21.214]   - Field: 'envir'
[17:28:21.214]   - Field: 'workers'
[17:28:21.215]   - Field: 'packages'
[17:28:21.215]   - Field: 'gc'
[17:28:21.215]   - Field: 'conditions'
[17:28:21.215]   - Field: 'persistent'
[17:28:21.215]   - Field: 'expr'
[17:28:21.216]   - Field: 'uuid'
[17:28:21.216]   - Field: 'seed'
[17:28:21.216]   - Field: 'version'
[17:28:21.216]   - Field: 'result'
[17:28:21.216]   - Field: 'asynchronous'
[17:28:21.216]   - Field: 'calls'
[17:28:21.217]   - Field: 'globals'
[17:28:21.217]   - Field: 'stdout'
[17:28:21.217]   - Field: 'earlySignal'
[17:28:21.217]   - Field: 'lazy'
[17:28:21.217]   - Field: 'state'
[17:28:21.217] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.218] - Launch lazy future ...
[17:28:21.218] Packages needed by the future expression (n = 0): <none>
[17:28:21.227] Packages needed by future strategies (n = 0): <none>
[17:28:21.227] {
[17:28:21.227]     {
[17:28:21.227]         {
[17:28:21.227]             ...future.startTime <- base::Sys.time()
[17:28:21.227]             {
[17:28:21.227]                 {
[17:28:21.227]                   {
[17:28:21.227]                     {
[17:28:21.227]                       {
[17:28:21.227]                         base::local({
[17:28:21.227]                           has_future <- base::requireNamespace("future", 
[17:28:21.227]                             quietly = TRUE)
[17:28:21.227]                           if (has_future) {
[17:28:21.227]                             ns <- base::getNamespace("future")
[17:28:21.227]                             version <- ns[[".package"]][["version"]]
[17:28:21.227]                             if (is.null(version)) 
[17:28:21.227]                               version <- utils::packageVersion("future")
[17:28:21.227]                           }
[17:28:21.227]                           else {
[17:28:21.227]                             version <- NULL
[17:28:21.227]                           }
[17:28:21.227]                           if (!has_future || version < "1.8.0") {
[17:28:21.227]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.227]                               "", base::R.version$version.string), 
[17:28:21.227]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:21.227]                                 base::R.version$platform, 8 * 
[17:28:21.227]                                   base::.Machine$sizeof.pointer), 
[17:28:21.227]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.227]                                 "release", "version")], collapse = " "), 
[17:28:21.227]                               hostname = base::Sys.info()[["nodename"]])
[17:28:21.227]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.227]                               info)
[17:28:21.227]                             info <- base::paste(info, collapse = "; ")
[17:28:21.227]                             if (!has_future) {
[17:28:21.227]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.227]                                 info)
[17:28:21.227]                             }
[17:28:21.227]                             else {
[17:28:21.227]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.227]                                 info, version)
[17:28:21.227]                             }
[17:28:21.227]                             base::stop(msg)
[17:28:21.227]                           }
[17:28:21.227]                         })
[17:28:21.227]                       }
[17:28:21.227]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.227]                       base::options(mc.cores = 1L)
[17:28:21.227]                     }
[17:28:21.227]                     ...future.strategy.old <- future::plan("list")
[17:28:21.227]                     options(future.plan = NULL)
[17:28:21.227]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.227]                     future::plan("default", .cleanup = FALSE, 
[17:28:21.227]                       .init = FALSE)
[17:28:21.227]                   }
[17:28:21.227]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:28:21.227]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:28:21.227]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:28:21.227]                 }
[17:28:21.227]                 ...future.workdir <- getwd()
[17:28:21.227]             }
[17:28:21.227]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.227]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.227]         }
[17:28:21.227]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.227]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.227]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.227]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.227]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.227]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.227]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.227]             base::names(...future.oldOptions))
[17:28:21.227]     }
[17:28:21.227]     if (FALSE) {
[17:28:21.227]     }
[17:28:21.227]     else {
[17:28:21.227]         if (TRUE) {
[17:28:21.227]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.227]                 open = "w")
[17:28:21.227]         }
[17:28:21.227]         else {
[17:28:21.227]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.227]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.227]         }
[17:28:21.227]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.227]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.227]             base::sink(type = "output", split = FALSE)
[17:28:21.227]             base::close(...future.stdout)
[17:28:21.227]         }, add = TRUE)
[17:28:21.227]     }
[17:28:21.227]     ...future.frame <- base::sys.nframe()
[17:28:21.227]     ...future.conditions <- base::list()
[17:28:21.227]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.227]     if (FALSE) {
[17:28:21.227]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.227]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.227]     }
[17:28:21.227]     ...future.result <- base::tryCatch({
[17:28:21.227]         base::withCallingHandlers({
[17:28:21.227]             ...future.value <- base::withVisible(base::local({
[17:28:21.227]                 ...future.makeSendCondition <- base::local({
[17:28:21.227]                   sendCondition <- NULL
[17:28:21.227]                   function(frame = 1L) {
[17:28:21.227]                     if (is.function(sendCondition)) 
[17:28:21.227]                       return(sendCondition)
[17:28:21.227]                     ns <- getNamespace("parallel")
[17:28:21.227]                     if (exists("sendData", mode = "function", 
[17:28:21.227]                       envir = ns)) {
[17:28:21.227]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.227]                         envir = ns)
[17:28:21.227]                       envir <- sys.frame(frame)
[17:28:21.227]                       master <- NULL
[17:28:21.227]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.227]                         !identical(envir, emptyenv())) {
[17:28:21.227]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.227]                           inherits = FALSE)) {
[17:28:21.227]                           master <- get("master", mode = "list", 
[17:28:21.227]                             envir = envir, inherits = FALSE)
[17:28:21.227]                           if (inherits(master, c("SOCKnode", 
[17:28:21.227]                             "SOCK0node"))) {
[17:28:21.227]                             sendCondition <<- function(cond) {
[17:28:21.227]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.227]                                 success = TRUE)
[17:28:21.227]                               parallel_sendData(master, data)
[17:28:21.227]                             }
[17:28:21.227]                             return(sendCondition)
[17:28:21.227]                           }
[17:28:21.227]                         }
[17:28:21.227]                         frame <- frame + 1L
[17:28:21.227]                         envir <- sys.frame(frame)
[17:28:21.227]                       }
[17:28:21.227]                     }
[17:28:21.227]                     sendCondition <<- function(cond) NULL
[17:28:21.227]                   }
[17:28:21.227]                 })
[17:28:21.227]                 withCallingHandlers({
[17:28:21.227]                   {
[17:28:21.227]                     sample(x, size = 1L)
[17:28:21.227]                   }
[17:28:21.227]                 }, immediateCondition = function(cond) {
[17:28:21.227]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.227]                   sendCondition(cond)
[17:28:21.227]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.227]                   {
[17:28:21.227]                     inherits <- base::inherits
[17:28:21.227]                     invokeRestart <- base::invokeRestart
[17:28:21.227]                     is.null <- base::is.null
[17:28:21.227]                     muffled <- FALSE
[17:28:21.227]                     if (inherits(cond, "message")) {
[17:28:21.227]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.227]                       if (muffled) 
[17:28:21.227]                         invokeRestart("muffleMessage")
[17:28:21.227]                     }
[17:28:21.227]                     else if (inherits(cond, "warning")) {
[17:28:21.227]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.227]                       if (muffled) 
[17:28:21.227]                         invokeRestart("muffleWarning")
[17:28:21.227]                     }
[17:28:21.227]                     else if (inherits(cond, "condition")) {
[17:28:21.227]                       if (!is.null(pattern)) {
[17:28:21.227]                         computeRestarts <- base::computeRestarts
[17:28:21.227]                         grepl <- base::grepl
[17:28:21.227]                         restarts <- computeRestarts(cond)
[17:28:21.227]                         for (restart in restarts) {
[17:28:21.227]                           name <- restart$name
[17:28:21.227]                           if (is.null(name)) 
[17:28:21.227]                             next
[17:28:21.227]                           if (!grepl(pattern, name)) 
[17:28:21.227]                             next
[17:28:21.227]                           invokeRestart(restart)
[17:28:21.227]                           muffled <- TRUE
[17:28:21.227]                           break
[17:28:21.227]                         }
[17:28:21.227]                       }
[17:28:21.227]                     }
[17:28:21.227]                     invisible(muffled)
[17:28:21.227]                   }
[17:28:21.227]                   muffleCondition(cond)
[17:28:21.227]                 })
[17:28:21.227]             }))
[17:28:21.227]             future::FutureResult(value = ...future.value$value, 
[17:28:21.227]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.227]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.227]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.227]                     ...future.globalenv.names))
[17:28:21.227]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.227]         }, condition = base::local({
[17:28:21.227]             c <- base::c
[17:28:21.227]             inherits <- base::inherits
[17:28:21.227]             invokeRestart <- base::invokeRestart
[17:28:21.227]             length <- base::length
[17:28:21.227]             list <- base::list
[17:28:21.227]             seq.int <- base::seq.int
[17:28:21.227]             signalCondition <- base::signalCondition
[17:28:21.227]             sys.calls <- base::sys.calls
[17:28:21.227]             `[[` <- base::`[[`
[17:28:21.227]             `+` <- base::`+`
[17:28:21.227]             `<<-` <- base::`<<-`
[17:28:21.227]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.227]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.227]                   3L)]
[17:28:21.227]             }
[17:28:21.227]             function(cond) {
[17:28:21.227]                 is_error <- inherits(cond, "error")
[17:28:21.227]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.227]                   NULL)
[17:28:21.227]                 if (is_error) {
[17:28:21.227]                   sessionInformation <- function() {
[17:28:21.227]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.227]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.227]                       search = base::search(), system = base::Sys.info())
[17:28:21.227]                   }
[17:28:21.227]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.227]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.227]                     cond$call), session = sessionInformation(), 
[17:28:21.227]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.227]                   signalCondition(cond)
[17:28:21.227]                 }
[17:28:21.227]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.227]                 "immediateCondition"))) {
[17:28:21.227]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.227]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.227]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.227]                   if (TRUE && !signal) {
[17:28:21.227]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.227]                     {
[17:28:21.227]                       inherits <- base::inherits
[17:28:21.227]                       invokeRestart <- base::invokeRestart
[17:28:21.227]                       is.null <- base::is.null
[17:28:21.227]                       muffled <- FALSE
[17:28:21.227]                       if (inherits(cond, "message")) {
[17:28:21.227]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.227]                         if (muffled) 
[17:28:21.227]                           invokeRestart("muffleMessage")
[17:28:21.227]                       }
[17:28:21.227]                       else if (inherits(cond, "warning")) {
[17:28:21.227]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.227]                         if (muffled) 
[17:28:21.227]                           invokeRestart("muffleWarning")
[17:28:21.227]                       }
[17:28:21.227]                       else if (inherits(cond, "condition")) {
[17:28:21.227]                         if (!is.null(pattern)) {
[17:28:21.227]                           computeRestarts <- base::computeRestarts
[17:28:21.227]                           grepl <- base::grepl
[17:28:21.227]                           restarts <- computeRestarts(cond)
[17:28:21.227]                           for (restart in restarts) {
[17:28:21.227]                             name <- restart$name
[17:28:21.227]                             if (is.null(name)) 
[17:28:21.227]                               next
[17:28:21.227]                             if (!grepl(pattern, name)) 
[17:28:21.227]                               next
[17:28:21.227]                             invokeRestart(restart)
[17:28:21.227]                             muffled <- TRUE
[17:28:21.227]                             break
[17:28:21.227]                           }
[17:28:21.227]                         }
[17:28:21.227]                       }
[17:28:21.227]                       invisible(muffled)
[17:28:21.227]                     }
[17:28:21.227]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.227]                   }
[17:28:21.227]                 }
[17:28:21.227]                 else {
[17:28:21.227]                   if (TRUE) {
[17:28:21.227]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.227]                     {
[17:28:21.227]                       inherits <- base::inherits
[17:28:21.227]                       invokeRestart <- base::invokeRestart
[17:28:21.227]                       is.null <- base::is.null
[17:28:21.227]                       muffled <- FALSE
[17:28:21.227]                       if (inherits(cond, "message")) {
[17:28:21.227]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.227]                         if (muffled) 
[17:28:21.227]                           invokeRestart("muffleMessage")
[17:28:21.227]                       }
[17:28:21.227]                       else if (inherits(cond, "warning")) {
[17:28:21.227]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.227]                         if (muffled) 
[17:28:21.227]                           invokeRestart("muffleWarning")
[17:28:21.227]                       }
[17:28:21.227]                       else if (inherits(cond, "condition")) {
[17:28:21.227]                         if (!is.null(pattern)) {
[17:28:21.227]                           computeRestarts <- base::computeRestarts
[17:28:21.227]                           grepl <- base::grepl
[17:28:21.227]                           restarts <- computeRestarts(cond)
[17:28:21.227]                           for (restart in restarts) {
[17:28:21.227]                             name <- restart$name
[17:28:21.227]                             if (is.null(name)) 
[17:28:21.227]                               next
[17:28:21.227]                             if (!grepl(pattern, name)) 
[17:28:21.227]                               next
[17:28:21.227]                             invokeRestart(restart)
[17:28:21.227]                             muffled <- TRUE
[17:28:21.227]                             break
[17:28:21.227]                           }
[17:28:21.227]                         }
[17:28:21.227]                       }
[17:28:21.227]                       invisible(muffled)
[17:28:21.227]                     }
[17:28:21.227]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.227]                   }
[17:28:21.227]                 }
[17:28:21.227]             }
[17:28:21.227]         }))
[17:28:21.227]     }, error = function(ex) {
[17:28:21.227]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.227]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.227]                 ...future.rng), started = ...future.startTime, 
[17:28:21.227]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.227]             version = "1.8"), class = "FutureResult")
[17:28:21.227]     }, finally = {
[17:28:21.227]         if (!identical(...future.workdir, getwd())) 
[17:28:21.227]             setwd(...future.workdir)
[17:28:21.227]         {
[17:28:21.227]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.227]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.227]             }
[17:28:21.227]             base::options(...future.oldOptions)
[17:28:21.227]             if (.Platform$OS.type == "windows") {
[17:28:21.227]                 old_names <- names(...future.oldEnvVars)
[17:28:21.227]                 envs <- base::Sys.getenv()
[17:28:21.227]                 names <- names(envs)
[17:28:21.227]                 common <- intersect(names, old_names)
[17:28:21.227]                 added <- setdiff(names, old_names)
[17:28:21.227]                 removed <- setdiff(old_names, names)
[17:28:21.227]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.227]                   envs[common]]
[17:28:21.227]                 NAMES <- toupper(changed)
[17:28:21.227]                 args <- list()
[17:28:21.227]                 for (kk in seq_along(NAMES)) {
[17:28:21.227]                   name <- changed[[kk]]
[17:28:21.227]                   NAME <- NAMES[[kk]]
[17:28:21.227]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.227]                     next
[17:28:21.227]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.227]                 }
[17:28:21.227]                 NAMES <- toupper(added)
[17:28:21.227]                 for (kk in seq_along(NAMES)) {
[17:28:21.227]                   name <- added[[kk]]
[17:28:21.227]                   NAME <- NAMES[[kk]]
[17:28:21.227]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.227]                     next
[17:28:21.227]                   args[[name]] <- ""
[17:28:21.227]                 }
[17:28:21.227]                 NAMES <- toupper(removed)
[17:28:21.227]                 for (kk in seq_along(NAMES)) {
[17:28:21.227]                   name <- removed[[kk]]
[17:28:21.227]                   NAME <- NAMES[[kk]]
[17:28:21.227]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.227]                     next
[17:28:21.227]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.227]                 }
[17:28:21.227]                 if (length(args) > 0) 
[17:28:21.227]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.227]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.227]             }
[17:28:21.227]             else {
[17:28:21.227]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.227]             }
[17:28:21.227]             {
[17:28:21.227]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.227]                   0L) {
[17:28:21.227]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.227]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.227]                   base::options(opts)
[17:28:21.227]                 }
[17:28:21.227]                 {
[17:28:21.227]                   {
[17:28:21.227]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.227]                     NULL
[17:28:21.227]                   }
[17:28:21.227]                   options(future.plan = NULL)
[17:28:21.227]                   if (is.na(NA_character_)) 
[17:28:21.227]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.227]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.227]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.227]                     .init = FALSE)
[17:28:21.227]                 }
[17:28:21.227]             }
[17:28:21.227]         }
[17:28:21.227]     })
[17:28:21.227]     if (TRUE) {
[17:28:21.227]         base::sink(type = "output", split = FALSE)
[17:28:21.227]         if (TRUE) {
[17:28:21.227]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.227]         }
[17:28:21.227]         else {
[17:28:21.227]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.227]         }
[17:28:21.227]         base::close(...future.stdout)
[17:28:21.227]         ...future.stdout <- NULL
[17:28:21.227]     }
[17:28:21.227]     ...future.result$conditions <- ...future.conditions
[17:28:21.227]     ...future.result$finished <- base::Sys.time()
[17:28:21.227]     ...future.result
[17:28:21.227] }
[17:28:21.232] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:21.249] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.250] - Validating connection of MultisessionFuture
[17:28:21.250] - received message: FutureResult
[17:28:21.250] - Received FutureResult
[17:28:21.250] - Erased future from FutureRegistry
[17:28:21.250] result() for ClusterFuture ...
[17:28:21.250] - result already collected: FutureResult
[17:28:21.251] result() for ClusterFuture ... done
[17:28:21.251] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:21.251] result() for ClusterFuture ...
[17:28:21.251] - result already collected: FutureResult
[17:28:21.251] result() for ClusterFuture ... done
[17:28:21.251] result() for ClusterFuture ...
[17:28:21.252] - result already collected: FutureResult
[17:28:21.252] result() for ClusterFuture ... done
[17:28:21.252] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:21.253] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:21.253] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:21.253] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:21.254] MultisessionFuture started
[17:28:21.254] - Launch lazy future ... done
[17:28:21.254] run() for 'MultisessionFuture' ... done
[17:28:21.255] getGlobalsAndPackages() ...
[17:28:21.255] Searching for globals...
[17:28:21.256] - globals found: [3] '{', 'sample', 'x'
[17:28:21.256] Searching for globals ... DONE
[17:28:21.257] Resolving globals: FALSE
[17:28:21.257] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.258] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.258] - globals: [1] 'x'
[17:28:21.258] 
[17:28:21.258] getGlobalsAndPackages() ... DONE
[17:28:21.258] run() for 'Future' ...
[17:28:21.259] - state: 'created'
[17:28:21.259] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.273] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.274] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.274]   - Field: 'node'
[17:28:21.274]   - Field: 'label'
[17:28:21.274]   - Field: 'local'
[17:28:21.274]   - Field: 'owner'
[17:28:21.275]   - Field: 'envir'
[17:28:21.275]   - Field: 'workers'
[17:28:21.275]   - Field: 'packages'
[17:28:21.275]   - Field: 'gc'
[17:28:21.275]   - Field: 'conditions'
[17:28:21.275]   - Field: 'persistent'
[17:28:21.276]   - Field: 'expr'
[17:28:21.276]   - Field: 'uuid'
[17:28:21.276]   - Field: 'seed'
[17:28:21.276]   - Field: 'version'
[17:28:21.276]   - Field: 'result'
[17:28:21.277]   - Field: 'asynchronous'
[17:28:21.277]   - Field: 'calls'
[17:28:21.277]   - Field: 'globals'
[17:28:21.277]   - Field: 'stdout'
[17:28:21.277]   - Field: 'earlySignal'
[17:28:21.277]   - Field: 'lazy'
[17:28:21.278]   - Field: 'state'
[17:28:21.278] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.278] - Launch lazy future ...
[17:28:21.278] Packages needed by the future expression (n = 0): <none>
[17:28:21.278] Packages needed by future strategies (n = 0): <none>
[17:28:21.279] {
[17:28:21.279]     {
[17:28:21.279]         {
[17:28:21.279]             ...future.startTime <- base::Sys.time()
[17:28:21.279]             {
[17:28:21.279]                 {
[17:28:21.279]                   {
[17:28:21.279]                     {
[17:28:21.279]                       {
[17:28:21.279]                         base::local({
[17:28:21.279]                           has_future <- base::requireNamespace("future", 
[17:28:21.279]                             quietly = TRUE)
[17:28:21.279]                           if (has_future) {
[17:28:21.279]                             ns <- base::getNamespace("future")
[17:28:21.279]                             version <- ns[[".package"]][["version"]]
[17:28:21.279]                             if (is.null(version)) 
[17:28:21.279]                               version <- utils::packageVersion("future")
[17:28:21.279]                           }
[17:28:21.279]                           else {
[17:28:21.279]                             version <- NULL
[17:28:21.279]                           }
[17:28:21.279]                           if (!has_future || version < "1.8.0") {
[17:28:21.279]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.279]                               "", base::R.version$version.string), 
[17:28:21.279]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:21.279]                                 base::R.version$platform, 8 * 
[17:28:21.279]                                   base::.Machine$sizeof.pointer), 
[17:28:21.279]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.279]                                 "release", "version")], collapse = " "), 
[17:28:21.279]                               hostname = base::Sys.info()[["nodename"]])
[17:28:21.279]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.279]                               info)
[17:28:21.279]                             info <- base::paste(info, collapse = "; ")
[17:28:21.279]                             if (!has_future) {
[17:28:21.279]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.279]                                 info)
[17:28:21.279]                             }
[17:28:21.279]                             else {
[17:28:21.279]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.279]                                 info, version)
[17:28:21.279]                             }
[17:28:21.279]                             base::stop(msg)
[17:28:21.279]                           }
[17:28:21.279]                         })
[17:28:21.279]                       }
[17:28:21.279]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.279]                       base::options(mc.cores = 1L)
[17:28:21.279]                     }
[17:28:21.279]                     ...future.strategy.old <- future::plan("list")
[17:28:21.279]                     options(future.plan = NULL)
[17:28:21.279]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.279]                     future::plan("default", .cleanup = FALSE, 
[17:28:21.279]                       .init = FALSE)
[17:28:21.279]                   }
[17:28:21.279]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:28:21.279]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:28:21.279]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:28:21.279]                 }
[17:28:21.279]                 ...future.workdir <- getwd()
[17:28:21.279]             }
[17:28:21.279]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.279]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.279]         }
[17:28:21.279]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.279]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.279]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.279]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.279]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.279]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.279]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.279]             base::names(...future.oldOptions))
[17:28:21.279]     }
[17:28:21.279]     if (FALSE) {
[17:28:21.279]     }
[17:28:21.279]     else {
[17:28:21.279]         if (TRUE) {
[17:28:21.279]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.279]                 open = "w")
[17:28:21.279]         }
[17:28:21.279]         else {
[17:28:21.279]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.279]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.279]         }
[17:28:21.279]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.279]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.279]             base::sink(type = "output", split = FALSE)
[17:28:21.279]             base::close(...future.stdout)
[17:28:21.279]         }, add = TRUE)
[17:28:21.279]     }
[17:28:21.279]     ...future.frame <- base::sys.nframe()
[17:28:21.279]     ...future.conditions <- base::list()
[17:28:21.279]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.279]     if (FALSE) {
[17:28:21.279]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.279]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.279]     }
[17:28:21.279]     ...future.result <- base::tryCatch({
[17:28:21.279]         base::withCallingHandlers({
[17:28:21.279]             ...future.value <- base::withVisible(base::local({
[17:28:21.279]                 ...future.makeSendCondition <- base::local({
[17:28:21.279]                   sendCondition <- NULL
[17:28:21.279]                   function(frame = 1L) {
[17:28:21.279]                     if (is.function(sendCondition)) 
[17:28:21.279]                       return(sendCondition)
[17:28:21.279]                     ns <- getNamespace("parallel")
[17:28:21.279]                     if (exists("sendData", mode = "function", 
[17:28:21.279]                       envir = ns)) {
[17:28:21.279]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.279]                         envir = ns)
[17:28:21.279]                       envir <- sys.frame(frame)
[17:28:21.279]                       master <- NULL
[17:28:21.279]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.279]                         !identical(envir, emptyenv())) {
[17:28:21.279]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.279]                           inherits = FALSE)) {
[17:28:21.279]                           master <- get("master", mode = "list", 
[17:28:21.279]                             envir = envir, inherits = FALSE)
[17:28:21.279]                           if (inherits(master, c("SOCKnode", 
[17:28:21.279]                             "SOCK0node"))) {
[17:28:21.279]                             sendCondition <<- function(cond) {
[17:28:21.279]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.279]                                 success = TRUE)
[17:28:21.279]                               parallel_sendData(master, data)
[17:28:21.279]                             }
[17:28:21.279]                             return(sendCondition)
[17:28:21.279]                           }
[17:28:21.279]                         }
[17:28:21.279]                         frame <- frame + 1L
[17:28:21.279]                         envir <- sys.frame(frame)
[17:28:21.279]                       }
[17:28:21.279]                     }
[17:28:21.279]                     sendCondition <<- function(cond) NULL
[17:28:21.279]                   }
[17:28:21.279]                 })
[17:28:21.279]                 withCallingHandlers({
[17:28:21.279]                   {
[17:28:21.279]                     sample(x, size = 1L)
[17:28:21.279]                   }
[17:28:21.279]                 }, immediateCondition = function(cond) {
[17:28:21.279]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.279]                   sendCondition(cond)
[17:28:21.279]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.279]                   {
[17:28:21.279]                     inherits <- base::inherits
[17:28:21.279]                     invokeRestart <- base::invokeRestart
[17:28:21.279]                     is.null <- base::is.null
[17:28:21.279]                     muffled <- FALSE
[17:28:21.279]                     if (inherits(cond, "message")) {
[17:28:21.279]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.279]                       if (muffled) 
[17:28:21.279]                         invokeRestart("muffleMessage")
[17:28:21.279]                     }
[17:28:21.279]                     else if (inherits(cond, "warning")) {
[17:28:21.279]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.279]                       if (muffled) 
[17:28:21.279]                         invokeRestart("muffleWarning")
[17:28:21.279]                     }
[17:28:21.279]                     else if (inherits(cond, "condition")) {
[17:28:21.279]                       if (!is.null(pattern)) {
[17:28:21.279]                         computeRestarts <- base::computeRestarts
[17:28:21.279]                         grepl <- base::grepl
[17:28:21.279]                         restarts <- computeRestarts(cond)
[17:28:21.279]                         for (restart in restarts) {
[17:28:21.279]                           name <- restart$name
[17:28:21.279]                           if (is.null(name)) 
[17:28:21.279]                             next
[17:28:21.279]                           if (!grepl(pattern, name)) 
[17:28:21.279]                             next
[17:28:21.279]                           invokeRestart(restart)
[17:28:21.279]                           muffled <- TRUE
[17:28:21.279]                           break
[17:28:21.279]                         }
[17:28:21.279]                       }
[17:28:21.279]                     }
[17:28:21.279]                     invisible(muffled)
[17:28:21.279]                   }
[17:28:21.279]                   muffleCondition(cond)
[17:28:21.279]                 })
[17:28:21.279]             }))
[17:28:21.279]             future::FutureResult(value = ...future.value$value, 
[17:28:21.279]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.279]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.279]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.279]                     ...future.globalenv.names))
[17:28:21.279]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.279]         }, condition = base::local({
[17:28:21.279]             c <- base::c
[17:28:21.279]             inherits <- base::inherits
[17:28:21.279]             invokeRestart <- base::invokeRestart
[17:28:21.279]             length <- base::length
[17:28:21.279]             list <- base::list
[17:28:21.279]             seq.int <- base::seq.int
[17:28:21.279]             signalCondition <- base::signalCondition
[17:28:21.279]             sys.calls <- base::sys.calls
[17:28:21.279]             `[[` <- base::`[[`
[17:28:21.279]             `+` <- base::`+`
[17:28:21.279]             `<<-` <- base::`<<-`
[17:28:21.279]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.279]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.279]                   3L)]
[17:28:21.279]             }
[17:28:21.279]             function(cond) {
[17:28:21.279]                 is_error <- inherits(cond, "error")
[17:28:21.279]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.279]                   NULL)
[17:28:21.279]                 if (is_error) {
[17:28:21.279]                   sessionInformation <- function() {
[17:28:21.279]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.279]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.279]                       search = base::search(), system = base::Sys.info())
[17:28:21.279]                   }
[17:28:21.279]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.279]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.279]                     cond$call), session = sessionInformation(), 
[17:28:21.279]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.279]                   signalCondition(cond)
[17:28:21.279]                 }
[17:28:21.279]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.279]                 "immediateCondition"))) {
[17:28:21.279]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.279]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.279]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.279]                   if (TRUE && !signal) {
[17:28:21.279]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.279]                     {
[17:28:21.279]                       inherits <- base::inherits
[17:28:21.279]                       invokeRestart <- base::invokeRestart
[17:28:21.279]                       is.null <- base::is.null
[17:28:21.279]                       muffled <- FALSE
[17:28:21.279]                       if (inherits(cond, "message")) {
[17:28:21.279]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.279]                         if (muffled) 
[17:28:21.279]                           invokeRestart("muffleMessage")
[17:28:21.279]                       }
[17:28:21.279]                       else if (inherits(cond, "warning")) {
[17:28:21.279]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.279]                         if (muffled) 
[17:28:21.279]                           invokeRestart("muffleWarning")
[17:28:21.279]                       }
[17:28:21.279]                       else if (inherits(cond, "condition")) {
[17:28:21.279]                         if (!is.null(pattern)) {
[17:28:21.279]                           computeRestarts <- base::computeRestarts
[17:28:21.279]                           grepl <- base::grepl
[17:28:21.279]                           restarts <- computeRestarts(cond)
[17:28:21.279]                           for (restart in restarts) {
[17:28:21.279]                             name <- restart$name
[17:28:21.279]                             if (is.null(name)) 
[17:28:21.279]                               next
[17:28:21.279]                             if (!grepl(pattern, name)) 
[17:28:21.279]                               next
[17:28:21.279]                             invokeRestart(restart)
[17:28:21.279]                             muffled <- TRUE
[17:28:21.279]                             break
[17:28:21.279]                           }
[17:28:21.279]                         }
[17:28:21.279]                       }
[17:28:21.279]                       invisible(muffled)
[17:28:21.279]                     }
[17:28:21.279]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.279]                   }
[17:28:21.279]                 }
[17:28:21.279]                 else {
[17:28:21.279]                   if (TRUE) {
[17:28:21.279]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.279]                     {
[17:28:21.279]                       inherits <- base::inherits
[17:28:21.279]                       invokeRestart <- base::invokeRestart
[17:28:21.279]                       is.null <- base::is.null
[17:28:21.279]                       muffled <- FALSE
[17:28:21.279]                       if (inherits(cond, "message")) {
[17:28:21.279]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.279]                         if (muffled) 
[17:28:21.279]                           invokeRestart("muffleMessage")
[17:28:21.279]                       }
[17:28:21.279]                       else if (inherits(cond, "warning")) {
[17:28:21.279]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.279]                         if (muffled) 
[17:28:21.279]                           invokeRestart("muffleWarning")
[17:28:21.279]                       }
[17:28:21.279]                       else if (inherits(cond, "condition")) {
[17:28:21.279]                         if (!is.null(pattern)) {
[17:28:21.279]                           computeRestarts <- base::computeRestarts
[17:28:21.279]                           grepl <- base::grepl
[17:28:21.279]                           restarts <- computeRestarts(cond)
[17:28:21.279]                           for (restart in restarts) {
[17:28:21.279]                             name <- restart$name
[17:28:21.279]                             if (is.null(name)) 
[17:28:21.279]                               next
[17:28:21.279]                             if (!grepl(pattern, name)) 
[17:28:21.279]                               next
[17:28:21.279]                             invokeRestart(restart)
[17:28:21.279]                             muffled <- TRUE
[17:28:21.279]                             break
[17:28:21.279]                           }
[17:28:21.279]                         }
[17:28:21.279]                       }
[17:28:21.279]                       invisible(muffled)
[17:28:21.279]                     }
[17:28:21.279]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.279]                   }
[17:28:21.279]                 }
[17:28:21.279]             }
[17:28:21.279]         }))
[17:28:21.279]     }, error = function(ex) {
[17:28:21.279]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.279]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.279]                 ...future.rng), started = ...future.startTime, 
[17:28:21.279]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.279]             version = "1.8"), class = "FutureResult")
[17:28:21.279]     }, finally = {
[17:28:21.279]         if (!identical(...future.workdir, getwd())) 
[17:28:21.279]             setwd(...future.workdir)
[17:28:21.279]         {
[17:28:21.279]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.279]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.279]             }
[17:28:21.279]             base::options(...future.oldOptions)
[17:28:21.279]             if (.Platform$OS.type == "windows") {
[17:28:21.279]                 old_names <- names(...future.oldEnvVars)
[17:28:21.279]                 envs <- base::Sys.getenv()
[17:28:21.279]                 names <- names(envs)
[17:28:21.279]                 common <- intersect(names, old_names)
[17:28:21.279]                 added <- setdiff(names, old_names)
[17:28:21.279]                 removed <- setdiff(old_names, names)
[17:28:21.279]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.279]                   envs[common]]
[17:28:21.279]                 NAMES <- toupper(changed)
[17:28:21.279]                 args <- list()
[17:28:21.279]                 for (kk in seq_along(NAMES)) {
[17:28:21.279]                   name <- changed[[kk]]
[17:28:21.279]                   NAME <- NAMES[[kk]]
[17:28:21.279]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.279]                     next
[17:28:21.279]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.279]                 }
[17:28:21.279]                 NAMES <- toupper(added)
[17:28:21.279]                 for (kk in seq_along(NAMES)) {
[17:28:21.279]                   name <- added[[kk]]
[17:28:21.279]                   NAME <- NAMES[[kk]]
[17:28:21.279]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.279]                     next
[17:28:21.279]                   args[[name]] <- ""
[17:28:21.279]                 }
[17:28:21.279]                 NAMES <- toupper(removed)
[17:28:21.279]                 for (kk in seq_along(NAMES)) {
[17:28:21.279]                   name <- removed[[kk]]
[17:28:21.279]                   NAME <- NAMES[[kk]]
[17:28:21.279]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.279]                     next
[17:28:21.279]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.279]                 }
[17:28:21.279]                 if (length(args) > 0) 
[17:28:21.279]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.279]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.279]             }
[17:28:21.279]             else {
[17:28:21.279]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.279]             }
[17:28:21.279]             {
[17:28:21.279]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.279]                   0L) {
[17:28:21.279]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.279]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.279]                   base::options(opts)
[17:28:21.279]                 }
[17:28:21.279]                 {
[17:28:21.279]                   {
[17:28:21.279]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.279]                     NULL
[17:28:21.279]                   }
[17:28:21.279]                   options(future.plan = NULL)
[17:28:21.279]                   if (is.na(NA_character_)) 
[17:28:21.279]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.279]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.279]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.279]                     .init = FALSE)
[17:28:21.279]                 }
[17:28:21.279]             }
[17:28:21.279]         }
[17:28:21.279]     })
[17:28:21.279]     if (TRUE) {
[17:28:21.279]         base::sink(type = "output", split = FALSE)
[17:28:21.279]         if (TRUE) {
[17:28:21.279]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.279]         }
[17:28:21.279]         else {
[17:28:21.279]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.279]         }
[17:28:21.279]         base::close(...future.stdout)
[17:28:21.279]         ...future.stdout <- NULL
[17:28:21.279]     }
[17:28:21.279]     ...future.result$conditions <- ...future.conditions
[17:28:21.279]     ...future.result$finished <- base::Sys.time()
[17:28:21.279]     ...future.result
[17:28:21.279] }
[17:28:21.284] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:21.296] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.296] - Validating connection of MultisessionFuture
[17:28:21.296] - received message: FutureResult
[17:28:21.297] - Received FutureResult
[17:28:21.297] - Erased future from FutureRegistry
[17:28:21.297] result() for ClusterFuture ...
[17:28:21.297] - result already collected: FutureResult
[17:28:21.297] result() for ClusterFuture ... done
[17:28:21.297] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:21.298] result() for ClusterFuture ...
[17:28:21.298] - result already collected: FutureResult
[17:28:21.298] result() for ClusterFuture ... done
[17:28:21.298] result() for ClusterFuture ...
[17:28:21.298] - result already collected: FutureResult
[17:28:21.298] result() for ClusterFuture ... done
[17:28:21.299] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:21.299] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:21.300] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:21.300] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:21.301] MultisessionFuture started
[17:28:21.301] - Launch lazy future ... done
[17:28:21.301] run() for 'MultisessionFuture' ... done
[17:28:21.301] result() for ClusterFuture ...
[17:28:21.302] - result already collected: FutureResult
[17:28:21.302] result() for ClusterFuture ... done
[17:28:21.302] result() for ClusterFuture ...
[17:28:21.302] - result already collected: FutureResult
[17:28:21.302] result() for ClusterFuture ... done
[17:28:21.302] result() for ClusterFuture ...
[17:28:21.303] - result already collected: FutureResult
[17:28:21.303] result() for ClusterFuture ... done
[17:28:21.303] result() for ClusterFuture ...
[17:28:21.303] - result already collected: FutureResult
[17:28:21.303] result() for ClusterFuture ... done
[17:28:21.303] result() for ClusterFuture ...
[17:28:21.304] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.304] - Validating connection of MultisessionFuture
[17:28:21.304] - received message: FutureResult
[17:28:21.304] - Received FutureResult
[17:28:21.304] - Erased future from FutureRegistry
[17:28:21.305] result() for ClusterFuture ...
[17:28:21.305] - result already collected: FutureResult
[17:28:21.305] result() for ClusterFuture ... done
[17:28:21.305] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:21.305] result() for ClusterFuture ... done
[17:28:21.305] result() for ClusterFuture ...
[17:28:21.306] - result already collected: FutureResult
[17:28:21.306] result() for ClusterFuture ... done
[17:28:21.306] result() for ClusterFuture ...
[17:28:21.306] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.306] - Validating connection of MultisessionFuture
[17:28:21.315] - received message: FutureResult
[17:28:21.315] - Received FutureResult
[17:28:21.315] - Erased future from FutureRegistry
[17:28:21.315] result() for ClusterFuture ...
[17:28:21.315] - result already collected: FutureResult
[17:28:21.316] result() for ClusterFuture ... done
[17:28:21.316] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:21.316] result() for ClusterFuture ... done
[17:28:21.316] result() for ClusterFuture ...
[17:28:21.316] - result already collected: FutureResult
[17:28:21.316] result() for ClusterFuture ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[17:28:21.317] getGlobalsAndPackages() ...
[17:28:21.317] Searching for globals...
[17:28:21.318] - globals found: [3] '{', 'sample', 'x'
[17:28:21.319] Searching for globals ... DONE
[17:28:21.319] Resolving globals: FALSE
[17:28:21.319] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.320] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.320] - globals: [1] 'x'
[17:28:21.320] 
[17:28:21.320] getGlobalsAndPackages() ... DONE
[17:28:21.321] run() for 'Future' ...
[17:28:21.321] - state: 'created'
[17:28:21.321] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.335] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.335] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.335]   - Field: 'node'
[17:28:21.336]   - Field: 'label'
[17:28:21.336]   - Field: 'local'
[17:28:21.336]   - Field: 'owner'
[17:28:21.336]   - Field: 'envir'
[17:28:21.336]   - Field: 'workers'
[17:28:21.336]   - Field: 'packages'
[17:28:21.337]   - Field: 'gc'
[17:28:21.337]   - Field: 'conditions'
[17:28:21.337]   - Field: 'persistent'
[17:28:21.337]   - Field: 'expr'
[17:28:21.337]   - Field: 'uuid'
[17:28:21.338]   - Field: 'seed'
[17:28:21.338]   - Field: 'version'
[17:28:21.338]   - Field: 'result'
[17:28:21.338]   - Field: 'asynchronous'
[17:28:21.338]   - Field: 'calls'
[17:28:21.339]   - Field: 'globals'
[17:28:21.339]   - Field: 'stdout'
[17:28:21.339]   - Field: 'earlySignal'
[17:28:21.339]   - Field: 'lazy'
[17:28:21.339]   - Field: 'state'
[17:28:21.340] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.340] - Launch lazy future ...
[17:28:21.340] Packages needed by the future expression (n = 0): <none>
[17:28:21.340] Packages needed by future strategies (n = 0): <none>
[17:28:21.341] {
[17:28:21.341]     {
[17:28:21.341]         {
[17:28:21.341]             ...future.startTime <- base::Sys.time()
[17:28:21.341]             {
[17:28:21.341]                 {
[17:28:21.341]                   {
[17:28:21.341]                     {
[17:28:21.341]                       {
[17:28:21.341]                         base::local({
[17:28:21.341]                           has_future <- base::requireNamespace("future", 
[17:28:21.341]                             quietly = TRUE)
[17:28:21.341]                           if (has_future) {
[17:28:21.341]                             ns <- base::getNamespace("future")
[17:28:21.341]                             version <- ns[[".package"]][["version"]]
[17:28:21.341]                             if (is.null(version)) 
[17:28:21.341]                               version <- utils::packageVersion("future")
[17:28:21.341]                           }
[17:28:21.341]                           else {
[17:28:21.341]                             version <- NULL
[17:28:21.341]                           }
[17:28:21.341]                           if (!has_future || version < "1.8.0") {
[17:28:21.341]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.341]                               "", base::R.version$version.string), 
[17:28:21.341]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:21.341]                                 base::R.version$platform, 8 * 
[17:28:21.341]                                   base::.Machine$sizeof.pointer), 
[17:28:21.341]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.341]                                 "release", "version")], collapse = " "), 
[17:28:21.341]                               hostname = base::Sys.info()[["nodename"]])
[17:28:21.341]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.341]                               info)
[17:28:21.341]                             info <- base::paste(info, collapse = "; ")
[17:28:21.341]                             if (!has_future) {
[17:28:21.341]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.341]                                 info)
[17:28:21.341]                             }
[17:28:21.341]                             else {
[17:28:21.341]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.341]                                 info, version)
[17:28:21.341]                             }
[17:28:21.341]                             base::stop(msg)
[17:28:21.341]                           }
[17:28:21.341]                         })
[17:28:21.341]                       }
[17:28:21.341]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.341]                       base::options(mc.cores = 1L)
[17:28:21.341]                     }
[17:28:21.341]                     ...future.strategy.old <- future::plan("list")
[17:28:21.341]                     options(future.plan = NULL)
[17:28:21.341]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.341]                     future::plan("default", .cleanup = FALSE, 
[17:28:21.341]                       .init = FALSE)
[17:28:21.341]                   }
[17:28:21.341]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:28:21.341]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:28:21.341]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:28:21.341]                 }
[17:28:21.341]                 ...future.workdir <- getwd()
[17:28:21.341]             }
[17:28:21.341]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.341]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.341]         }
[17:28:21.341]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.341]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.341]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.341]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.341]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.341]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.341]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.341]             base::names(...future.oldOptions))
[17:28:21.341]     }
[17:28:21.341]     if (FALSE) {
[17:28:21.341]     }
[17:28:21.341]     else {
[17:28:21.341]         if (TRUE) {
[17:28:21.341]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.341]                 open = "w")
[17:28:21.341]         }
[17:28:21.341]         else {
[17:28:21.341]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.341]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.341]         }
[17:28:21.341]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.341]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.341]             base::sink(type = "output", split = FALSE)
[17:28:21.341]             base::close(...future.stdout)
[17:28:21.341]         }, add = TRUE)
[17:28:21.341]     }
[17:28:21.341]     ...future.frame <- base::sys.nframe()
[17:28:21.341]     ...future.conditions <- base::list()
[17:28:21.341]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.341]     if (FALSE) {
[17:28:21.341]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.341]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.341]     }
[17:28:21.341]     ...future.result <- base::tryCatch({
[17:28:21.341]         base::withCallingHandlers({
[17:28:21.341]             ...future.value <- base::withVisible(base::local({
[17:28:21.341]                 ...future.makeSendCondition <- base::local({
[17:28:21.341]                   sendCondition <- NULL
[17:28:21.341]                   function(frame = 1L) {
[17:28:21.341]                     if (is.function(sendCondition)) 
[17:28:21.341]                       return(sendCondition)
[17:28:21.341]                     ns <- getNamespace("parallel")
[17:28:21.341]                     if (exists("sendData", mode = "function", 
[17:28:21.341]                       envir = ns)) {
[17:28:21.341]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.341]                         envir = ns)
[17:28:21.341]                       envir <- sys.frame(frame)
[17:28:21.341]                       master <- NULL
[17:28:21.341]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.341]                         !identical(envir, emptyenv())) {
[17:28:21.341]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.341]                           inherits = FALSE)) {
[17:28:21.341]                           master <- get("master", mode = "list", 
[17:28:21.341]                             envir = envir, inherits = FALSE)
[17:28:21.341]                           if (inherits(master, c("SOCKnode", 
[17:28:21.341]                             "SOCK0node"))) {
[17:28:21.341]                             sendCondition <<- function(cond) {
[17:28:21.341]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.341]                                 success = TRUE)
[17:28:21.341]                               parallel_sendData(master, data)
[17:28:21.341]                             }
[17:28:21.341]                             return(sendCondition)
[17:28:21.341]                           }
[17:28:21.341]                         }
[17:28:21.341]                         frame <- frame + 1L
[17:28:21.341]                         envir <- sys.frame(frame)
[17:28:21.341]                       }
[17:28:21.341]                     }
[17:28:21.341]                     sendCondition <<- function(cond) NULL
[17:28:21.341]                   }
[17:28:21.341]                 })
[17:28:21.341]                 withCallingHandlers({
[17:28:21.341]                   {
[17:28:21.341]                     sample(x, size = 1L)
[17:28:21.341]                   }
[17:28:21.341]                 }, immediateCondition = function(cond) {
[17:28:21.341]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.341]                   sendCondition(cond)
[17:28:21.341]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.341]                   {
[17:28:21.341]                     inherits <- base::inherits
[17:28:21.341]                     invokeRestart <- base::invokeRestart
[17:28:21.341]                     is.null <- base::is.null
[17:28:21.341]                     muffled <- FALSE
[17:28:21.341]                     if (inherits(cond, "message")) {
[17:28:21.341]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.341]                       if (muffled) 
[17:28:21.341]                         invokeRestart("muffleMessage")
[17:28:21.341]                     }
[17:28:21.341]                     else if (inherits(cond, "warning")) {
[17:28:21.341]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.341]                       if (muffled) 
[17:28:21.341]                         invokeRestart("muffleWarning")
[17:28:21.341]                     }
[17:28:21.341]                     else if (inherits(cond, "condition")) {
[17:28:21.341]                       if (!is.null(pattern)) {
[17:28:21.341]                         computeRestarts <- base::computeRestarts
[17:28:21.341]                         grepl <- base::grepl
[17:28:21.341]                         restarts <- computeRestarts(cond)
[17:28:21.341]                         for (restart in restarts) {
[17:28:21.341]                           name <- restart$name
[17:28:21.341]                           if (is.null(name)) 
[17:28:21.341]                             next
[17:28:21.341]                           if (!grepl(pattern, name)) 
[17:28:21.341]                             next
[17:28:21.341]                           invokeRestart(restart)
[17:28:21.341]                           muffled <- TRUE
[17:28:21.341]                           break
[17:28:21.341]                         }
[17:28:21.341]                       }
[17:28:21.341]                     }
[17:28:21.341]                     invisible(muffled)
[17:28:21.341]                   }
[17:28:21.341]                   muffleCondition(cond)
[17:28:21.341]                 })
[17:28:21.341]             }))
[17:28:21.341]             future::FutureResult(value = ...future.value$value, 
[17:28:21.341]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.341]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.341]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.341]                     ...future.globalenv.names))
[17:28:21.341]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.341]         }, condition = base::local({
[17:28:21.341]             c <- base::c
[17:28:21.341]             inherits <- base::inherits
[17:28:21.341]             invokeRestart <- base::invokeRestart
[17:28:21.341]             length <- base::length
[17:28:21.341]             list <- base::list
[17:28:21.341]             seq.int <- base::seq.int
[17:28:21.341]             signalCondition <- base::signalCondition
[17:28:21.341]             sys.calls <- base::sys.calls
[17:28:21.341]             `[[` <- base::`[[`
[17:28:21.341]             `+` <- base::`+`
[17:28:21.341]             `<<-` <- base::`<<-`
[17:28:21.341]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.341]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.341]                   3L)]
[17:28:21.341]             }
[17:28:21.341]             function(cond) {
[17:28:21.341]                 is_error <- inherits(cond, "error")
[17:28:21.341]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.341]                   NULL)
[17:28:21.341]                 if (is_error) {
[17:28:21.341]                   sessionInformation <- function() {
[17:28:21.341]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.341]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.341]                       search = base::search(), system = base::Sys.info())
[17:28:21.341]                   }
[17:28:21.341]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.341]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.341]                     cond$call), session = sessionInformation(), 
[17:28:21.341]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.341]                   signalCondition(cond)
[17:28:21.341]                 }
[17:28:21.341]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.341]                 "immediateCondition"))) {
[17:28:21.341]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.341]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.341]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.341]                   if (TRUE && !signal) {
[17:28:21.341]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.341]                     {
[17:28:21.341]                       inherits <- base::inherits
[17:28:21.341]                       invokeRestart <- base::invokeRestart
[17:28:21.341]                       is.null <- base::is.null
[17:28:21.341]                       muffled <- FALSE
[17:28:21.341]                       if (inherits(cond, "message")) {
[17:28:21.341]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.341]                         if (muffled) 
[17:28:21.341]                           invokeRestart("muffleMessage")
[17:28:21.341]                       }
[17:28:21.341]                       else if (inherits(cond, "warning")) {
[17:28:21.341]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.341]                         if (muffled) 
[17:28:21.341]                           invokeRestart("muffleWarning")
[17:28:21.341]                       }
[17:28:21.341]                       else if (inherits(cond, "condition")) {
[17:28:21.341]                         if (!is.null(pattern)) {
[17:28:21.341]                           computeRestarts <- base::computeRestarts
[17:28:21.341]                           grepl <- base::grepl
[17:28:21.341]                           restarts <- computeRestarts(cond)
[17:28:21.341]                           for (restart in restarts) {
[17:28:21.341]                             name <- restart$name
[17:28:21.341]                             if (is.null(name)) 
[17:28:21.341]                               next
[17:28:21.341]                             if (!grepl(pattern, name)) 
[17:28:21.341]                               next
[17:28:21.341]                             invokeRestart(restart)
[17:28:21.341]                             muffled <- TRUE
[17:28:21.341]                             break
[17:28:21.341]                           }
[17:28:21.341]                         }
[17:28:21.341]                       }
[17:28:21.341]                       invisible(muffled)
[17:28:21.341]                     }
[17:28:21.341]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.341]                   }
[17:28:21.341]                 }
[17:28:21.341]                 else {
[17:28:21.341]                   if (TRUE) {
[17:28:21.341]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.341]                     {
[17:28:21.341]                       inherits <- base::inherits
[17:28:21.341]                       invokeRestart <- base::invokeRestart
[17:28:21.341]                       is.null <- base::is.null
[17:28:21.341]                       muffled <- FALSE
[17:28:21.341]                       if (inherits(cond, "message")) {
[17:28:21.341]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.341]                         if (muffled) 
[17:28:21.341]                           invokeRestart("muffleMessage")
[17:28:21.341]                       }
[17:28:21.341]                       else if (inherits(cond, "warning")) {
[17:28:21.341]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.341]                         if (muffled) 
[17:28:21.341]                           invokeRestart("muffleWarning")
[17:28:21.341]                       }
[17:28:21.341]                       else if (inherits(cond, "condition")) {
[17:28:21.341]                         if (!is.null(pattern)) {
[17:28:21.341]                           computeRestarts <- base::computeRestarts
[17:28:21.341]                           grepl <- base::grepl
[17:28:21.341]                           restarts <- computeRestarts(cond)
[17:28:21.341]                           for (restart in restarts) {
[17:28:21.341]                             name <- restart$name
[17:28:21.341]                             if (is.null(name)) 
[17:28:21.341]                               next
[17:28:21.341]                             if (!grepl(pattern, name)) 
[17:28:21.341]                               next
[17:28:21.341]                             invokeRestart(restart)
[17:28:21.341]                             muffled <- TRUE
[17:28:21.341]                             break
[17:28:21.341]                           }
[17:28:21.341]                         }
[17:28:21.341]                       }
[17:28:21.341]                       invisible(muffled)
[17:28:21.341]                     }
[17:28:21.341]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.341]                   }
[17:28:21.341]                 }
[17:28:21.341]             }
[17:28:21.341]         }))
[17:28:21.341]     }, error = function(ex) {
[17:28:21.341]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.341]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.341]                 ...future.rng), started = ...future.startTime, 
[17:28:21.341]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.341]             version = "1.8"), class = "FutureResult")
[17:28:21.341]     }, finally = {
[17:28:21.341]         if (!identical(...future.workdir, getwd())) 
[17:28:21.341]             setwd(...future.workdir)
[17:28:21.341]         {
[17:28:21.341]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.341]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.341]             }
[17:28:21.341]             base::options(...future.oldOptions)
[17:28:21.341]             if (.Platform$OS.type == "windows") {
[17:28:21.341]                 old_names <- names(...future.oldEnvVars)
[17:28:21.341]                 envs <- base::Sys.getenv()
[17:28:21.341]                 names <- names(envs)
[17:28:21.341]                 common <- intersect(names, old_names)
[17:28:21.341]                 added <- setdiff(names, old_names)
[17:28:21.341]                 removed <- setdiff(old_names, names)
[17:28:21.341]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.341]                   envs[common]]
[17:28:21.341]                 NAMES <- toupper(changed)
[17:28:21.341]                 args <- list()
[17:28:21.341]                 for (kk in seq_along(NAMES)) {
[17:28:21.341]                   name <- changed[[kk]]
[17:28:21.341]                   NAME <- NAMES[[kk]]
[17:28:21.341]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.341]                     next
[17:28:21.341]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.341]                 }
[17:28:21.341]                 NAMES <- toupper(added)
[17:28:21.341]                 for (kk in seq_along(NAMES)) {
[17:28:21.341]                   name <- added[[kk]]
[17:28:21.341]                   NAME <- NAMES[[kk]]
[17:28:21.341]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.341]                     next
[17:28:21.341]                   args[[name]] <- ""
[17:28:21.341]                 }
[17:28:21.341]                 NAMES <- toupper(removed)
[17:28:21.341]                 for (kk in seq_along(NAMES)) {
[17:28:21.341]                   name <- removed[[kk]]
[17:28:21.341]                   NAME <- NAMES[[kk]]
[17:28:21.341]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.341]                     next
[17:28:21.341]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.341]                 }
[17:28:21.341]                 if (length(args) > 0) 
[17:28:21.341]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.341]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.341]             }
[17:28:21.341]             else {
[17:28:21.341]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.341]             }
[17:28:21.341]             {
[17:28:21.341]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.341]                   0L) {
[17:28:21.341]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.341]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.341]                   base::options(opts)
[17:28:21.341]                 }
[17:28:21.341]                 {
[17:28:21.341]                   {
[17:28:21.341]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.341]                     NULL
[17:28:21.341]                   }
[17:28:21.341]                   options(future.plan = NULL)
[17:28:21.341]                   if (is.na(NA_character_)) 
[17:28:21.341]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.341]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.341]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.341]                     .init = FALSE)
[17:28:21.341]                 }
[17:28:21.341]             }
[17:28:21.341]         }
[17:28:21.341]     })
[17:28:21.341]     if (TRUE) {
[17:28:21.341]         base::sink(type = "output", split = FALSE)
[17:28:21.341]         if (TRUE) {
[17:28:21.341]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.341]         }
[17:28:21.341]         else {
[17:28:21.341]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.341]         }
[17:28:21.341]         base::close(...future.stdout)
[17:28:21.341]         ...future.stdout <- NULL
[17:28:21.341]     }
[17:28:21.341]     ...future.result$conditions <- ...future.conditions
[17:28:21.341]     ...future.result$finished <- base::Sys.time()
[17:28:21.341]     ...future.result
[17:28:21.341] }
[17:28:21.347] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:21.347] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:21.347] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:21.348] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:21.348] MultisessionFuture started
[17:28:21.349] - Launch lazy future ... done
[17:28:21.349] run() for 'MultisessionFuture' ... done
[17:28:21.349] getGlobalsAndPackages() ...
[17:28:21.350] Searching for globals...
[17:28:21.351] - globals found: [3] '{', 'sample', 'x'
[17:28:21.351] Searching for globals ... DONE
[17:28:21.351] Resolving globals: FALSE
[17:28:21.352] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.352] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.353] - globals: [1] 'x'
[17:28:21.353] 
[17:28:21.353] getGlobalsAndPackages() ... DONE
[17:28:21.353] run() for 'Future' ...
[17:28:21.354] - state: 'created'
[17:28:21.354] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.368] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.368] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.368]   - Field: 'node'
[17:28:21.368]   - Field: 'label'
[17:28:21.369]   - Field: 'local'
[17:28:21.369]   - Field: 'owner'
[17:28:21.369]   - Field: 'envir'
[17:28:21.369]   - Field: 'workers'
[17:28:21.369]   - Field: 'packages'
[17:28:21.369]   - Field: 'gc'
[17:28:21.370]   - Field: 'conditions'
[17:28:21.370]   - Field: 'persistent'
[17:28:21.370]   - Field: 'expr'
[17:28:21.370]   - Field: 'uuid'
[17:28:21.370]   - Field: 'seed'
[17:28:21.371]   - Field: 'version'
[17:28:21.371]   - Field: 'result'
[17:28:21.371]   - Field: 'asynchronous'
[17:28:21.371]   - Field: 'calls'
[17:28:21.371]   - Field: 'globals'
[17:28:21.372]   - Field: 'stdout'
[17:28:21.372]   - Field: 'earlySignal'
[17:28:21.372]   - Field: 'lazy'
[17:28:21.372]   - Field: 'state'
[17:28:21.372] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.373] - Launch lazy future ...
[17:28:21.373] Packages needed by the future expression (n = 0): <none>
[17:28:21.373] Packages needed by future strategies (n = 0): <none>
[17:28:21.374] {
[17:28:21.374]     {
[17:28:21.374]         {
[17:28:21.374]             ...future.startTime <- base::Sys.time()
[17:28:21.374]             {
[17:28:21.374]                 {
[17:28:21.374]                   {
[17:28:21.374]                     {
[17:28:21.374]                       {
[17:28:21.374]                         base::local({
[17:28:21.374]                           has_future <- base::requireNamespace("future", 
[17:28:21.374]                             quietly = TRUE)
[17:28:21.374]                           if (has_future) {
[17:28:21.374]                             ns <- base::getNamespace("future")
[17:28:21.374]                             version <- ns[[".package"]][["version"]]
[17:28:21.374]                             if (is.null(version)) 
[17:28:21.374]                               version <- utils::packageVersion("future")
[17:28:21.374]                           }
[17:28:21.374]                           else {
[17:28:21.374]                             version <- NULL
[17:28:21.374]                           }
[17:28:21.374]                           if (!has_future || version < "1.8.0") {
[17:28:21.374]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.374]                               "", base::R.version$version.string), 
[17:28:21.374]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:21.374]                                 base::R.version$platform, 8 * 
[17:28:21.374]                                   base::.Machine$sizeof.pointer), 
[17:28:21.374]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.374]                                 "release", "version")], collapse = " "), 
[17:28:21.374]                               hostname = base::Sys.info()[["nodename"]])
[17:28:21.374]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.374]                               info)
[17:28:21.374]                             info <- base::paste(info, collapse = "; ")
[17:28:21.374]                             if (!has_future) {
[17:28:21.374]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.374]                                 info)
[17:28:21.374]                             }
[17:28:21.374]                             else {
[17:28:21.374]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.374]                                 info, version)
[17:28:21.374]                             }
[17:28:21.374]                             base::stop(msg)
[17:28:21.374]                           }
[17:28:21.374]                         })
[17:28:21.374]                       }
[17:28:21.374]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.374]                       base::options(mc.cores = 1L)
[17:28:21.374]                     }
[17:28:21.374]                     ...future.strategy.old <- future::plan("list")
[17:28:21.374]                     options(future.plan = NULL)
[17:28:21.374]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.374]                     future::plan("default", .cleanup = FALSE, 
[17:28:21.374]                       .init = FALSE)
[17:28:21.374]                   }
[17:28:21.374]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:28:21.374]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:28:21.374]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:28:21.374]                 }
[17:28:21.374]                 ...future.workdir <- getwd()
[17:28:21.374]             }
[17:28:21.374]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.374]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.374]         }
[17:28:21.374]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.374]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.374]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.374]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.374]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.374]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.374]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.374]             base::names(...future.oldOptions))
[17:28:21.374]     }
[17:28:21.374]     if (FALSE) {
[17:28:21.374]     }
[17:28:21.374]     else {
[17:28:21.374]         if (TRUE) {
[17:28:21.374]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.374]                 open = "w")
[17:28:21.374]         }
[17:28:21.374]         else {
[17:28:21.374]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.374]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.374]         }
[17:28:21.374]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.374]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.374]             base::sink(type = "output", split = FALSE)
[17:28:21.374]             base::close(...future.stdout)
[17:28:21.374]         }, add = TRUE)
[17:28:21.374]     }
[17:28:21.374]     ...future.frame <- base::sys.nframe()
[17:28:21.374]     ...future.conditions <- base::list()
[17:28:21.374]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.374]     if (FALSE) {
[17:28:21.374]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.374]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.374]     }
[17:28:21.374]     ...future.result <- base::tryCatch({
[17:28:21.374]         base::withCallingHandlers({
[17:28:21.374]             ...future.value <- base::withVisible(base::local({
[17:28:21.374]                 ...future.makeSendCondition <- base::local({
[17:28:21.374]                   sendCondition <- NULL
[17:28:21.374]                   function(frame = 1L) {
[17:28:21.374]                     if (is.function(sendCondition)) 
[17:28:21.374]                       return(sendCondition)
[17:28:21.374]                     ns <- getNamespace("parallel")
[17:28:21.374]                     if (exists("sendData", mode = "function", 
[17:28:21.374]                       envir = ns)) {
[17:28:21.374]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.374]                         envir = ns)
[17:28:21.374]                       envir <- sys.frame(frame)
[17:28:21.374]                       master <- NULL
[17:28:21.374]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.374]                         !identical(envir, emptyenv())) {
[17:28:21.374]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.374]                           inherits = FALSE)) {
[17:28:21.374]                           master <- get("master", mode = "list", 
[17:28:21.374]                             envir = envir, inherits = FALSE)
[17:28:21.374]                           if (inherits(master, c("SOCKnode", 
[17:28:21.374]                             "SOCK0node"))) {
[17:28:21.374]                             sendCondition <<- function(cond) {
[17:28:21.374]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.374]                                 success = TRUE)
[17:28:21.374]                               parallel_sendData(master, data)
[17:28:21.374]                             }
[17:28:21.374]                             return(sendCondition)
[17:28:21.374]                           }
[17:28:21.374]                         }
[17:28:21.374]                         frame <- frame + 1L
[17:28:21.374]                         envir <- sys.frame(frame)
[17:28:21.374]                       }
[17:28:21.374]                     }
[17:28:21.374]                     sendCondition <<- function(cond) NULL
[17:28:21.374]                   }
[17:28:21.374]                 })
[17:28:21.374]                 withCallingHandlers({
[17:28:21.374]                   {
[17:28:21.374]                     sample(x, size = 1L)
[17:28:21.374]                   }
[17:28:21.374]                 }, immediateCondition = function(cond) {
[17:28:21.374]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.374]                   sendCondition(cond)
[17:28:21.374]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.374]                   {
[17:28:21.374]                     inherits <- base::inherits
[17:28:21.374]                     invokeRestart <- base::invokeRestart
[17:28:21.374]                     is.null <- base::is.null
[17:28:21.374]                     muffled <- FALSE
[17:28:21.374]                     if (inherits(cond, "message")) {
[17:28:21.374]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.374]                       if (muffled) 
[17:28:21.374]                         invokeRestart("muffleMessage")
[17:28:21.374]                     }
[17:28:21.374]                     else if (inherits(cond, "warning")) {
[17:28:21.374]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.374]                       if (muffled) 
[17:28:21.374]                         invokeRestart("muffleWarning")
[17:28:21.374]                     }
[17:28:21.374]                     else if (inherits(cond, "condition")) {
[17:28:21.374]                       if (!is.null(pattern)) {
[17:28:21.374]                         computeRestarts <- base::computeRestarts
[17:28:21.374]                         grepl <- base::grepl
[17:28:21.374]                         restarts <- computeRestarts(cond)
[17:28:21.374]                         for (restart in restarts) {
[17:28:21.374]                           name <- restart$name
[17:28:21.374]                           if (is.null(name)) 
[17:28:21.374]                             next
[17:28:21.374]                           if (!grepl(pattern, name)) 
[17:28:21.374]                             next
[17:28:21.374]                           invokeRestart(restart)
[17:28:21.374]                           muffled <- TRUE
[17:28:21.374]                           break
[17:28:21.374]                         }
[17:28:21.374]                       }
[17:28:21.374]                     }
[17:28:21.374]                     invisible(muffled)
[17:28:21.374]                   }
[17:28:21.374]                   muffleCondition(cond)
[17:28:21.374]                 })
[17:28:21.374]             }))
[17:28:21.374]             future::FutureResult(value = ...future.value$value, 
[17:28:21.374]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.374]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.374]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.374]                     ...future.globalenv.names))
[17:28:21.374]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.374]         }, condition = base::local({
[17:28:21.374]             c <- base::c
[17:28:21.374]             inherits <- base::inherits
[17:28:21.374]             invokeRestart <- base::invokeRestart
[17:28:21.374]             length <- base::length
[17:28:21.374]             list <- base::list
[17:28:21.374]             seq.int <- base::seq.int
[17:28:21.374]             signalCondition <- base::signalCondition
[17:28:21.374]             sys.calls <- base::sys.calls
[17:28:21.374]             `[[` <- base::`[[`
[17:28:21.374]             `+` <- base::`+`
[17:28:21.374]             `<<-` <- base::`<<-`
[17:28:21.374]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.374]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.374]                   3L)]
[17:28:21.374]             }
[17:28:21.374]             function(cond) {
[17:28:21.374]                 is_error <- inherits(cond, "error")
[17:28:21.374]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.374]                   NULL)
[17:28:21.374]                 if (is_error) {
[17:28:21.374]                   sessionInformation <- function() {
[17:28:21.374]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.374]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.374]                       search = base::search(), system = base::Sys.info())
[17:28:21.374]                   }
[17:28:21.374]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.374]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.374]                     cond$call), session = sessionInformation(), 
[17:28:21.374]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.374]                   signalCondition(cond)
[17:28:21.374]                 }
[17:28:21.374]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.374]                 "immediateCondition"))) {
[17:28:21.374]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.374]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.374]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.374]                   if (TRUE && !signal) {
[17:28:21.374]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.374]                     {
[17:28:21.374]                       inherits <- base::inherits
[17:28:21.374]                       invokeRestart <- base::invokeRestart
[17:28:21.374]                       is.null <- base::is.null
[17:28:21.374]                       muffled <- FALSE
[17:28:21.374]                       if (inherits(cond, "message")) {
[17:28:21.374]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.374]                         if (muffled) 
[17:28:21.374]                           invokeRestart("muffleMessage")
[17:28:21.374]                       }
[17:28:21.374]                       else if (inherits(cond, "warning")) {
[17:28:21.374]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.374]                         if (muffled) 
[17:28:21.374]                           invokeRestart("muffleWarning")
[17:28:21.374]                       }
[17:28:21.374]                       else if (inherits(cond, "condition")) {
[17:28:21.374]                         if (!is.null(pattern)) {
[17:28:21.374]                           computeRestarts <- base::computeRestarts
[17:28:21.374]                           grepl <- base::grepl
[17:28:21.374]                           restarts <- computeRestarts(cond)
[17:28:21.374]                           for (restart in restarts) {
[17:28:21.374]                             name <- restart$name
[17:28:21.374]                             if (is.null(name)) 
[17:28:21.374]                               next
[17:28:21.374]                             if (!grepl(pattern, name)) 
[17:28:21.374]                               next
[17:28:21.374]                             invokeRestart(restart)
[17:28:21.374]                             muffled <- TRUE
[17:28:21.374]                             break
[17:28:21.374]                           }
[17:28:21.374]                         }
[17:28:21.374]                       }
[17:28:21.374]                       invisible(muffled)
[17:28:21.374]                     }
[17:28:21.374]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.374]                   }
[17:28:21.374]                 }
[17:28:21.374]                 else {
[17:28:21.374]                   if (TRUE) {
[17:28:21.374]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.374]                     {
[17:28:21.374]                       inherits <- base::inherits
[17:28:21.374]                       invokeRestart <- base::invokeRestart
[17:28:21.374]                       is.null <- base::is.null
[17:28:21.374]                       muffled <- FALSE
[17:28:21.374]                       if (inherits(cond, "message")) {
[17:28:21.374]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.374]                         if (muffled) 
[17:28:21.374]                           invokeRestart("muffleMessage")
[17:28:21.374]                       }
[17:28:21.374]                       else if (inherits(cond, "warning")) {
[17:28:21.374]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.374]                         if (muffled) 
[17:28:21.374]                           invokeRestart("muffleWarning")
[17:28:21.374]                       }
[17:28:21.374]                       else if (inherits(cond, "condition")) {
[17:28:21.374]                         if (!is.null(pattern)) {
[17:28:21.374]                           computeRestarts <- base::computeRestarts
[17:28:21.374]                           grepl <- base::grepl
[17:28:21.374]                           restarts <- computeRestarts(cond)
[17:28:21.374]                           for (restart in restarts) {
[17:28:21.374]                             name <- restart$name
[17:28:21.374]                             if (is.null(name)) 
[17:28:21.374]                               next
[17:28:21.374]                             if (!grepl(pattern, name)) 
[17:28:21.374]                               next
[17:28:21.374]                             invokeRestart(restart)
[17:28:21.374]                             muffled <- TRUE
[17:28:21.374]                             break
[17:28:21.374]                           }
[17:28:21.374]                         }
[17:28:21.374]                       }
[17:28:21.374]                       invisible(muffled)
[17:28:21.374]                     }
[17:28:21.374]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.374]                   }
[17:28:21.374]                 }
[17:28:21.374]             }
[17:28:21.374]         }))
[17:28:21.374]     }, error = function(ex) {
[17:28:21.374]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.374]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.374]                 ...future.rng), started = ...future.startTime, 
[17:28:21.374]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.374]             version = "1.8"), class = "FutureResult")
[17:28:21.374]     }, finally = {
[17:28:21.374]         if (!identical(...future.workdir, getwd())) 
[17:28:21.374]             setwd(...future.workdir)
[17:28:21.374]         {
[17:28:21.374]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.374]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.374]             }
[17:28:21.374]             base::options(...future.oldOptions)
[17:28:21.374]             if (.Platform$OS.type == "windows") {
[17:28:21.374]                 old_names <- names(...future.oldEnvVars)
[17:28:21.374]                 envs <- base::Sys.getenv()
[17:28:21.374]                 names <- names(envs)
[17:28:21.374]                 common <- intersect(names, old_names)
[17:28:21.374]                 added <- setdiff(names, old_names)
[17:28:21.374]                 removed <- setdiff(old_names, names)
[17:28:21.374]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.374]                   envs[common]]
[17:28:21.374]                 NAMES <- toupper(changed)
[17:28:21.374]                 args <- list()
[17:28:21.374]                 for (kk in seq_along(NAMES)) {
[17:28:21.374]                   name <- changed[[kk]]
[17:28:21.374]                   NAME <- NAMES[[kk]]
[17:28:21.374]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.374]                     next
[17:28:21.374]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.374]                 }
[17:28:21.374]                 NAMES <- toupper(added)
[17:28:21.374]                 for (kk in seq_along(NAMES)) {
[17:28:21.374]                   name <- added[[kk]]
[17:28:21.374]                   NAME <- NAMES[[kk]]
[17:28:21.374]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.374]                     next
[17:28:21.374]                   args[[name]] <- ""
[17:28:21.374]                 }
[17:28:21.374]                 NAMES <- toupper(removed)
[17:28:21.374]                 for (kk in seq_along(NAMES)) {
[17:28:21.374]                   name <- removed[[kk]]
[17:28:21.374]                   NAME <- NAMES[[kk]]
[17:28:21.374]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.374]                     next
[17:28:21.374]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.374]                 }
[17:28:21.374]                 if (length(args) > 0) 
[17:28:21.374]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.374]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.374]             }
[17:28:21.374]             else {
[17:28:21.374]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.374]             }
[17:28:21.374]             {
[17:28:21.374]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.374]                   0L) {
[17:28:21.374]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.374]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.374]                   base::options(opts)
[17:28:21.374]                 }
[17:28:21.374]                 {
[17:28:21.374]                   {
[17:28:21.374]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.374]                     NULL
[17:28:21.374]                   }
[17:28:21.374]                   options(future.plan = NULL)
[17:28:21.374]                   if (is.na(NA_character_)) 
[17:28:21.374]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.374]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.374]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.374]                     .init = FALSE)
[17:28:21.374]                 }
[17:28:21.374]             }
[17:28:21.374]         }
[17:28:21.374]     })
[17:28:21.374]     if (TRUE) {
[17:28:21.374]         base::sink(type = "output", split = FALSE)
[17:28:21.374]         if (TRUE) {
[17:28:21.374]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.374]         }
[17:28:21.374]         else {
[17:28:21.374]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.374]         }
[17:28:21.374]         base::close(...future.stdout)
[17:28:21.374]         ...future.stdout <- NULL
[17:28:21.374]     }
[17:28:21.374]     ...future.result$conditions <- ...future.conditions
[17:28:21.374]     ...future.result$finished <- base::Sys.time()
[17:28:21.374]     ...future.result
[17:28:21.374] }
[17:28:21.379] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:21.379] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:21.380] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:21.380] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:21.380] MultisessionFuture started
[17:28:21.381] - Launch lazy future ... done
[17:28:21.381] run() for 'MultisessionFuture' ... done
[17:28:21.381] getGlobalsAndPackages() ...
[17:28:21.382] Searching for globals...
[17:28:21.383] - globals found: [3] '{', 'sample', 'x'
[17:28:21.383] Searching for globals ... DONE
[17:28:21.383] Resolving globals: FALSE
[17:28:21.384] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.384] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.385] - globals: [1] 'x'
[17:28:21.385] 
[17:28:21.385] getGlobalsAndPackages() ... DONE
[17:28:21.385] run() for 'Future' ...
[17:28:21.386] - state: 'created'
[17:28:21.386] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.400] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.400] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.400]   - Field: 'node'
[17:28:21.400]   - Field: 'label'
[17:28:21.400]   - Field: 'local'
[17:28:21.401]   - Field: 'owner'
[17:28:21.401]   - Field: 'envir'
[17:28:21.401]   - Field: 'workers'
[17:28:21.401]   - Field: 'packages'
[17:28:21.401]   - Field: 'gc'
[17:28:21.402]   - Field: 'conditions'
[17:28:21.402]   - Field: 'persistent'
[17:28:21.402]   - Field: 'expr'
[17:28:21.402]   - Field: 'uuid'
[17:28:21.402]   - Field: 'seed'
[17:28:21.403]   - Field: 'version'
[17:28:21.403]   - Field: 'result'
[17:28:21.403]   - Field: 'asynchronous'
[17:28:21.403]   - Field: 'calls'
[17:28:21.403]   - Field: 'globals'
[17:28:21.403]   - Field: 'stdout'
[17:28:21.404]   - Field: 'earlySignal'
[17:28:21.404]   - Field: 'lazy'
[17:28:21.404]   - Field: 'state'
[17:28:21.404] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.404] - Launch lazy future ...
[17:28:21.405] Packages needed by the future expression (n = 0): <none>
[17:28:21.405] Packages needed by future strategies (n = 0): <none>
[17:28:21.406] {
[17:28:21.406]     {
[17:28:21.406]         {
[17:28:21.406]             ...future.startTime <- base::Sys.time()
[17:28:21.406]             {
[17:28:21.406]                 {
[17:28:21.406]                   {
[17:28:21.406]                     {
[17:28:21.406]                       {
[17:28:21.406]                         base::local({
[17:28:21.406]                           has_future <- base::requireNamespace("future", 
[17:28:21.406]                             quietly = TRUE)
[17:28:21.406]                           if (has_future) {
[17:28:21.406]                             ns <- base::getNamespace("future")
[17:28:21.406]                             version <- ns[[".package"]][["version"]]
[17:28:21.406]                             if (is.null(version)) 
[17:28:21.406]                               version <- utils::packageVersion("future")
[17:28:21.406]                           }
[17:28:21.406]                           else {
[17:28:21.406]                             version <- NULL
[17:28:21.406]                           }
[17:28:21.406]                           if (!has_future || version < "1.8.0") {
[17:28:21.406]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.406]                               "", base::R.version$version.string), 
[17:28:21.406]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:21.406]                                 base::R.version$platform, 8 * 
[17:28:21.406]                                   base::.Machine$sizeof.pointer), 
[17:28:21.406]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.406]                                 "release", "version")], collapse = " "), 
[17:28:21.406]                               hostname = base::Sys.info()[["nodename"]])
[17:28:21.406]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.406]                               info)
[17:28:21.406]                             info <- base::paste(info, collapse = "; ")
[17:28:21.406]                             if (!has_future) {
[17:28:21.406]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.406]                                 info)
[17:28:21.406]                             }
[17:28:21.406]                             else {
[17:28:21.406]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.406]                                 info, version)
[17:28:21.406]                             }
[17:28:21.406]                             base::stop(msg)
[17:28:21.406]                           }
[17:28:21.406]                         })
[17:28:21.406]                       }
[17:28:21.406]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.406]                       base::options(mc.cores = 1L)
[17:28:21.406]                     }
[17:28:21.406]                     ...future.strategy.old <- future::plan("list")
[17:28:21.406]                     options(future.plan = NULL)
[17:28:21.406]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.406]                     future::plan("default", .cleanup = FALSE, 
[17:28:21.406]                       .init = FALSE)
[17:28:21.406]                   }
[17:28:21.406]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:28:21.406]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:28:21.406]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:28:21.406]                 }
[17:28:21.406]                 ...future.workdir <- getwd()
[17:28:21.406]             }
[17:28:21.406]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.406]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.406]         }
[17:28:21.406]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.406]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.406]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.406]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.406]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.406]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.406]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.406]             base::names(...future.oldOptions))
[17:28:21.406]     }
[17:28:21.406]     if (FALSE) {
[17:28:21.406]     }
[17:28:21.406]     else {
[17:28:21.406]         if (TRUE) {
[17:28:21.406]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.406]                 open = "w")
[17:28:21.406]         }
[17:28:21.406]         else {
[17:28:21.406]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.406]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.406]         }
[17:28:21.406]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.406]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.406]             base::sink(type = "output", split = FALSE)
[17:28:21.406]             base::close(...future.stdout)
[17:28:21.406]         }, add = TRUE)
[17:28:21.406]     }
[17:28:21.406]     ...future.frame <- base::sys.nframe()
[17:28:21.406]     ...future.conditions <- base::list()
[17:28:21.406]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.406]     if (FALSE) {
[17:28:21.406]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.406]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.406]     }
[17:28:21.406]     ...future.result <- base::tryCatch({
[17:28:21.406]         base::withCallingHandlers({
[17:28:21.406]             ...future.value <- base::withVisible(base::local({
[17:28:21.406]                 ...future.makeSendCondition <- base::local({
[17:28:21.406]                   sendCondition <- NULL
[17:28:21.406]                   function(frame = 1L) {
[17:28:21.406]                     if (is.function(sendCondition)) 
[17:28:21.406]                       return(sendCondition)
[17:28:21.406]                     ns <- getNamespace("parallel")
[17:28:21.406]                     if (exists("sendData", mode = "function", 
[17:28:21.406]                       envir = ns)) {
[17:28:21.406]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.406]                         envir = ns)
[17:28:21.406]                       envir <- sys.frame(frame)
[17:28:21.406]                       master <- NULL
[17:28:21.406]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.406]                         !identical(envir, emptyenv())) {
[17:28:21.406]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.406]                           inherits = FALSE)) {
[17:28:21.406]                           master <- get("master", mode = "list", 
[17:28:21.406]                             envir = envir, inherits = FALSE)
[17:28:21.406]                           if (inherits(master, c("SOCKnode", 
[17:28:21.406]                             "SOCK0node"))) {
[17:28:21.406]                             sendCondition <<- function(cond) {
[17:28:21.406]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.406]                                 success = TRUE)
[17:28:21.406]                               parallel_sendData(master, data)
[17:28:21.406]                             }
[17:28:21.406]                             return(sendCondition)
[17:28:21.406]                           }
[17:28:21.406]                         }
[17:28:21.406]                         frame <- frame + 1L
[17:28:21.406]                         envir <- sys.frame(frame)
[17:28:21.406]                       }
[17:28:21.406]                     }
[17:28:21.406]                     sendCondition <<- function(cond) NULL
[17:28:21.406]                   }
[17:28:21.406]                 })
[17:28:21.406]                 withCallingHandlers({
[17:28:21.406]                   {
[17:28:21.406]                     sample(x, size = 1L)
[17:28:21.406]                   }
[17:28:21.406]                 }, immediateCondition = function(cond) {
[17:28:21.406]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.406]                   sendCondition(cond)
[17:28:21.406]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.406]                   {
[17:28:21.406]                     inherits <- base::inherits
[17:28:21.406]                     invokeRestart <- base::invokeRestart
[17:28:21.406]                     is.null <- base::is.null
[17:28:21.406]                     muffled <- FALSE
[17:28:21.406]                     if (inherits(cond, "message")) {
[17:28:21.406]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.406]                       if (muffled) 
[17:28:21.406]                         invokeRestart("muffleMessage")
[17:28:21.406]                     }
[17:28:21.406]                     else if (inherits(cond, "warning")) {
[17:28:21.406]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.406]                       if (muffled) 
[17:28:21.406]                         invokeRestart("muffleWarning")
[17:28:21.406]                     }
[17:28:21.406]                     else if (inherits(cond, "condition")) {
[17:28:21.406]                       if (!is.null(pattern)) {
[17:28:21.406]                         computeRestarts <- base::computeRestarts
[17:28:21.406]                         grepl <- base::grepl
[17:28:21.406]                         restarts <- computeRestarts(cond)
[17:28:21.406]                         for (restart in restarts) {
[17:28:21.406]                           name <- restart$name
[17:28:21.406]                           if (is.null(name)) 
[17:28:21.406]                             next
[17:28:21.406]                           if (!grepl(pattern, name)) 
[17:28:21.406]                             next
[17:28:21.406]                           invokeRestart(restart)
[17:28:21.406]                           muffled <- TRUE
[17:28:21.406]                           break
[17:28:21.406]                         }
[17:28:21.406]                       }
[17:28:21.406]                     }
[17:28:21.406]                     invisible(muffled)
[17:28:21.406]                   }
[17:28:21.406]                   muffleCondition(cond)
[17:28:21.406]                 })
[17:28:21.406]             }))
[17:28:21.406]             future::FutureResult(value = ...future.value$value, 
[17:28:21.406]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.406]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.406]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.406]                     ...future.globalenv.names))
[17:28:21.406]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.406]         }, condition = base::local({
[17:28:21.406]             c <- base::c
[17:28:21.406]             inherits <- base::inherits
[17:28:21.406]             invokeRestart <- base::invokeRestart
[17:28:21.406]             length <- base::length
[17:28:21.406]             list <- base::list
[17:28:21.406]             seq.int <- base::seq.int
[17:28:21.406]             signalCondition <- base::signalCondition
[17:28:21.406]             sys.calls <- base::sys.calls
[17:28:21.406]             `[[` <- base::`[[`
[17:28:21.406]             `+` <- base::`+`
[17:28:21.406]             `<<-` <- base::`<<-`
[17:28:21.406]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.406]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.406]                   3L)]
[17:28:21.406]             }
[17:28:21.406]             function(cond) {
[17:28:21.406]                 is_error <- inherits(cond, "error")
[17:28:21.406]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.406]                   NULL)
[17:28:21.406]                 if (is_error) {
[17:28:21.406]                   sessionInformation <- function() {
[17:28:21.406]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.406]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.406]                       search = base::search(), system = base::Sys.info())
[17:28:21.406]                   }
[17:28:21.406]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.406]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.406]                     cond$call), session = sessionInformation(), 
[17:28:21.406]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.406]                   signalCondition(cond)
[17:28:21.406]                 }
[17:28:21.406]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.406]                 "immediateCondition"))) {
[17:28:21.406]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.406]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.406]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.406]                   if (TRUE && !signal) {
[17:28:21.406]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.406]                     {
[17:28:21.406]                       inherits <- base::inherits
[17:28:21.406]                       invokeRestart <- base::invokeRestart
[17:28:21.406]                       is.null <- base::is.null
[17:28:21.406]                       muffled <- FALSE
[17:28:21.406]                       if (inherits(cond, "message")) {
[17:28:21.406]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.406]                         if (muffled) 
[17:28:21.406]                           invokeRestart("muffleMessage")
[17:28:21.406]                       }
[17:28:21.406]                       else if (inherits(cond, "warning")) {
[17:28:21.406]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.406]                         if (muffled) 
[17:28:21.406]                           invokeRestart("muffleWarning")
[17:28:21.406]                       }
[17:28:21.406]                       else if (inherits(cond, "condition")) {
[17:28:21.406]                         if (!is.null(pattern)) {
[17:28:21.406]                           computeRestarts <- base::computeRestarts
[17:28:21.406]                           grepl <- base::grepl
[17:28:21.406]                           restarts <- computeRestarts(cond)
[17:28:21.406]                           for (restart in restarts) {
[17:28:21.406]                             name <- restart$name
[17:28:21.406]                             if (is.null(name)) 
[17:28:21.406]                               next
[17:28:21.406]                             if (!grepl(pattern, name)) 
[17:28:21.406]                               next
[17:28:21.406]                             invokeRestart(restart)
[17:28:21.406]                             muffled <- TRUE
[17:28:21.406]                             break
[17:28:21.406]                           }
[17:28:21.406]                         }
[17:28:21.406]                       }
[17:28:21.406]                       invisible(muffled)
[17:28:21.406]                     }
[17:28:21.406]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.406]                   }
[17:28:21.406]                 }
[17:28:21.406]                 else {
[17:28:21.406]                   if (TRUE) {
[17:28:21.406]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.406]                     {
[17:28:21.406]                       inherits <- base::inherits
[17:28:21.406]                       invokeRestart <- base::invokeRestart
[17:28:21.406]                       is.null <- base::is.null
[17:28:21.406]                       muffled <- FALSE
[17:28:21.406]                       if (inherits(cond, "message")) {
[17:28:21.406]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.406]                         if (muffled) 
[17:28:21.406]                           invokeRestart("muffleMessage")
[17:28:21.406]                       }
[17:28:21.406]                       else if (inherits(cond, "warning")) {
[17:28:21.406]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.406]                         if (muffled) 
[17:28:21.406]                           invokeRestart("muffleWarning")
[17:28:21.406]                       }
[17:28:21.406]                       else if (inherits(cond, "condition")) {
[17:28:21.406]                         if (!is.null(pattern)) {
[17:28:21.406]                           computeRestarts <- base::computeRestarts
[17:28:21.406]                           grepl <- base::grepl
[17:28:21.406]                           restarts <- computeRestarts(cond)
[17:28:21.406]                           for (restart in restarts) {
[17:28:21.406]                             name <- restart$name
[17:28:21.406]                             if (is.null(name)) 
[17:28:21.406]                               next
[17:28:21.406]                             if (!grepl(pattern, name)) 
[17:28:21.406]                               next
[17:28:21.406]                             invokeRestart(restart)
[17:28:21.406]                             muffled <- TRUE
[17:28:21.406]                             break
[17:28:21.406]                           }
[17:28:21.406]                         }
[17:28:21.406]                       }
[17:28:21.406]                       invisible(muffled)
[17:28:21.406]                     }
[17:28:21.406]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.406]                   }
[17:28:21.406]                 }
[17:28:21.406]             }
[17:28:21.406]         }))
[17:28:21.406]     }, error = function(ex) {
[17:28:21.406]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.406]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.406]                 ...future.rng), started = ...future.startTime, 
[17:28:21.406]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.406]             version = "1.8"), class = "FutureResult")
[17:28:21.406]     }, finally = {
[17:28:21.406]         if (!identical(...future.workdir, getwd())) 
[17:28:21.406]             setwd(...future.workdir)
[17:28:21.406]         {
[17:28:21.406]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.406]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.406]             }
[17:28:21.406]             base::options(...future.oldOptions)
[17:28:21.406]             if (.Platform$OS.type == "windows") {
[17:28:21.406]                 old_names <- names(...future.oldEnvVars)
[17:28:21.406]                 envs <- base::Sys.getenv()
[17:28:21.406]                 names <- names(envs)
[17:28:21.406]                 common <- intersect(names, old_names)
[17:28:21.406]                 added <- setdiff(names, old_names)
[17:28:21.406]                 removed <- setdiff(old_names, names)
[17:28:21.406]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.406]                   envs[common]]
[17:28:21.406]                 NAMES <- toupper(changed)
[17:28:21.406]                 args <- list()
[17:28:21.406]                 for (kk in seq_along(NAMES)) {
[17:28:21.406]                   name <- changed[[kk]]
[17:28:21.406]                   NAME <- NAMES[[kk]]
[17:28:21.406]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.406]                     next
[17:28:21.406]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.406]                 }
[17:28:21.406]                 NAMES <- toupper(added)
[17:28:21.406]                 for (kk in seq_along(NAMES)) {
[17:28:21.406]                   name <- added[[kk]]
[17:28:21.406]                   NAME <- NAMES[[kk]]
[17:28:21.406]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.406]                     next
[17:28:21.406]                   args[[name]] <- ""
[17:28:21.406]                 }
[17:28:21.406]                 NAMES <- toupper(removed)
[17:28:21.406]                 for (kk in seq_along(NAMES)) {
[17:28:21.406]                   name <- removed[[kk]]
[17:28:21.406]                   NAME <- NAMES[[kk]]
[17:28:21.406]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.406]                     next
[17:28:21.406]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.406]                 }
[17:28:21.406]                 if (length(args) > 0) 
[17:28:21.406]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.406]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.406]             }
[17:28:21.406]             else {
[17:28:21.406]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.406]             }
[17:28:21.406]             {
[17:28:21.406]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.406]                   0L) {
[17:28:21.406]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.406]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.406]                   base::options(opts)
[17:28:21.406]                 }
[17:28:21.406]                 {
[17:28:21.406]                   {
[17:28:21.406]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.406]                     NULL
[17:28:21.406]                   }
[17:28:21.406]                   options(future.plan = NULL)
[17:28:21.406]                   if (is.na(NA_character_)) 
[17:28:21.406]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.406]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.406]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.406]                     .init = FALSE)
[17:28:21.406]                 }
[17:28:21.406]             }
[17:28:21.406]         }
[17:28:21.406]     })
[17:28:21.406]     if (TRUE) {
[17:28:21.406]         base::sink(type = "output", split = FALSE)
[17:28:21.406]         if (TRUE) {
[17:28:21.406]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.406]         }
[17:28:21.406]         else {
[17:28:21.406]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.406]         }
[17:28:21.406]         base::close(...future.stdout)
[17:28:21.406]         ...future.stdout <- NULL
[17:28:21.406]     }
[17:28:21.406]     ...future.result$conditions <- ...future.conditions
[17:28:21.406]     ...future.result$finished <- base::Sys.time()
[17:28:21.406]     ...future.result
[17:28:21.406] }
[17:28:21.411] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:21.429] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.430] - Validating connection of MultisessionFuture
[17:28:21.430] - received message: FutureResult
[17:28:21.430] - Received FutureResult
[17:28:21.430] - Erased future from FutureRegistry
[17:28:21.431] result() for ClusterFuture ...
[17:28:21.431] - result already collected: FutureResult
[17:28:21.431] result() for ClusterFuture ... done
[17:28:21.431] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:21.431] result() for ClusterFuture ...
[17:28:21.431] - result already collected: FutureResult
[17:28:21.432] result() for ClusterFuture ... done
[17:28:21.432] result() for ClusterFuture ...
[17:28:21.432] - result already collected: FutureResult
[17:28:21.432] result() for ClusterFuture ... done
[17:28:21.433] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:21.433] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:21.434] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:21.434] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:21.435] MultisessionFuture started
[17:28:21.435] - Launch lazy future ... done
[17:28:21.435] run() for 'MultisessionFuture' ... done
[17:28:21.436] getGlobalsAndPackages() ...
[17:28:21.436] Searching for globals...
[17:28:21.437] - globals found: [3] '{', 'sample', 'x'
[17:28:21.437] Searching for globals ... DONE
[17:28:21.437] Resolving globals: FALSE
[17:28:21.438] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.438] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.439] - globals: [1] 'x'
[17:28:21.439] 
[17:28:21.439] getGlobalsAndPackages() ... DONE
[17:28:21.439] run() for 'Future' ...
[17:28:21.440] - state: 'created'
[17:28:21.440] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.453] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.454] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.454]   - Field: 'node'
[17:28:21.454]   - Field: 'label'
[17:28:21.454]   - Field: 'local'
[17:28:21.454]   - Field: 'owner'
[17:28:21.455]   - Field: 'envir'
[17:28:21.455]   - Field: 'workers'
[17:28:21.455]   - Field: 'packages'
[17:28:21.455]   - Field: 'gc'
[17:28:21.455]   - Field: 'conditions'
[17:28:21.456]   - Field: 'persistent'
[17:28:21.456]   - Field: 'expr'
[17:28:21.456]   - Field: 'uuid'
[17:28:21.456]   - Field: 'seed'
[17:28:21.456]   - Field: 'version'
[17:28:21.457]   - Field: 'result'
[17:28:21.457]   - Field: 'asynchronous'
[17:28:21.457]   - Field: 'calls'
[17:28:21.457]   - Field: 'globals'
[17:28:21.457]   - Field: 'stdout'
[17:28:21.458]   - Field: 'earlySignal'
[17:28:21.458]   - Field: 'lazy'
[17:28:21.458]   - Field: 'state'
[17:28:21.458] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.458] - Launch lazy future ...
[17:28:21.459] Packages needed by the future expression (n = 0): <none>
[17:28:21.459] Packages needed by future strategies (n = 0): <none>
[17:28:21.460] {
[17:28:21.460]     {
[17:28:21.460]         {
[17:28:21.460]             ...future.startTime <- base::Sys.time()
[17:28:21.460]             {
[17:28:21.460]                 {
[17:28:21.460]                   {
[17:28:21.460]                     {
[17:28:21.460]                       {
[17:28:21.460]                         base::local({
[17:28:21.460]                           has_future <- base::requireNamespace("future", 
[17:28:21.460]                             quietly = TRUE)
[17:28:21.460]                           if (has_future) {
[17:28:21.460]                             ns <- base::getNamespace("future")
[17:28:21.460]                             version <- ns[[".package"]][["version"]]
[17:28:21.460]                             if (is.null(version)) 
[17:28:21.460]                               version <- utils::packageVersion("future")
[17:28:21.460]                           }
[17:28:21.460]                           else {
[17:28:21.460]                             version <- NULL
[17:28:21.460]                           }
[17:28:21.460]                           if (!has_future || version < "1.8.0") {
[17:28:21.460]                             info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.460]                               "", base::R.version$version.string), 
[17:28:21.460]                               platform = base::sprintf("%s (%s-bit)", 
[17:28:21.460]                                 base::R.version$platform, 8 * 
[17:28:21.460]                                   base::.Machine$sizeof.pointer), 
[17:28:21.460]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.460]                                 "release", "version")], collapse = " "), 
[17:28:21.460]                               hostname = base::Sys.info()[["nodename"]])
[17:28:21.460]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.460]                               info)
[17:28:21.460]                             info <- base::paste(info, collapse = "; ")
[17:28:21.460]                             if (!has_future) {
[17:28:21.460]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.460]                                 info)
[17:28:21.460]                             }
[17:28:21.460]                             else {
[17:28:21.460]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.460]                                 info, version)
[17:28:21.460]                             }
[17:28:21.460]                             base::stop(msg)
[17:28:21.460]                           }
[17:28:21.460]                         })
[17:28:21.460]                       }
[17:28:21.460]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.460]                       base::options(mc.cores = 1L)
[17:28:21.460]                     }
[17:28:21.460]                     ...future.strategy.old <- future::plan("list")
[17:28:21.460]                     options(future.plan = NULL)
[17:28:21.460]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.460]                     future::plan("default", .cleanup = FALSE, 
[17:28:21.460]                       .init = FALSE)
[17:28:21.460]                   }
[17:28:21.460]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:28:21.460]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:28:21.460]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:28:21.460]                 }
[17:28:21.460]                 ...future.workdir <- getwd()
[17:28:21.460]             }
[17:28:21.460]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.460]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.460]         }
[17:28:21.460]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.460]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.460]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.460]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.460]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.460]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.460]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.460]             base::names(...future.oldOptions))
[17:28:21.460]     }
[17:28:21.460]     if (FALSE) {
[17:28:21.460]     }
[17:28:21.460]     else {
[17:28:21.460]         if (TRUE) {
[17:28:21.460]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.460]                 open = "w")
[17:28:21.460]         }
[17:28:21.460]         else {
[17:28:21.460]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.460]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.460]         }
[17:28:21.460]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.460]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.460]             base::sink(type = "output", split = FALSE)
[17:28:21.460]             base::close(...future.stdout)
[17:28:21.460]         }, add = TRUE)
[17:28:21.460]     }
[17:28:21.460]     ...future.frame <- base::sys.nframe()
[17:28:21.460]     ...future.conditions <- base::list()
[17:28:21.460]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.460]     if (FALSE) {
[17:28:21.460]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.460]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.460]     }
[17:28:21.460]     ...future.result <- base::tryCatch({
[17:28:21.460]         base::withCallingHandlers({
[17:28:21.460]             ...future.value <- base::withVisible(base::local({
[17:28:21.460]                 ...future.makeSendCondition <- base::local({
[17:28:21.460]                   sendCondition <- NULL
[17:28:21.460]                   function(frame = 1L) {
[17:28:21.460]                     if (is.function(sendCondition)) 
[17:28:21.460]                       return(sendCondition)
[17:28:21.460]                     ns <- getNamespace("parallel")
[17:28:21.460]                     if (exists("sendData", mode = "function", 
[17:28:21.460]                       envir = ns)) {
[17:28:21.460]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.460]                         envir = ns)
[17:28:21.460]                       envir <- sys.frame(frame)
[17:28:21.460]                       master <- NULL
[17:28:21.460]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.460]                         !identical(envir, emptyenv())) {
[17:28:21.460]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.460]                           inherits = FALSE)) {
[17:28:21.460]                           master <- get("master", mode = "list", 
[17:28:21.460]                             envir = envir, inherits = FALSE)
[17:28:21.460]                           if (inherits(master, c("SOCKnode", 
[17:28:21.460]                             "SOCK0node"))) {
[17:28:21.460]                             sendCondition <<- function(cond) {
[17:28:21.460]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.460]                                 success = TRUE)
[17:28:21.460]                               parallel_sendData(master, data)
[17:28:21.460]                             }
[17:28:21.460]                             return(sendCondition)
[17:28:21.460]                           }
[17:28:21.460]                         }
[17:28:21.460]                         frame <- frame + 1L
[17:28:21.460]                         envir <- sys.frame(frame)
[17:28:21.460]                       }
[17:28:21.460]                     }
[17:28:21.460]                     sendCondition <<- function(cond) NULL
[17:28:21.460]                   }
[17:28:21.460]                 })
[17:28:21.460]                 withCallingHandlers({
[17:28:21.460]                   {
[17:28:21.460]                     sample(x, size = 1L)
[17:28:21.460]                   }
[17:28:21.460]                 }, immediateCondition = function(cond) {
[17:28:21.460]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.460]                   sendCondition(cond)
[17:28:21.460]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.460]                   {
[17:28:21.460]                     inherits <- base::inherits
[17:28:21.460]                     invokeRestart <- base::invokeRestart
[17:28:21.460]                     is.null <- base::is.null
[17:28:21.460]                     muffled <- FALSE
[17:28:21.460]                     if (inherits(cond, "message")) {
[17:28:21.460]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.460]                       if (muffled) 
[17:28:21.460]                         invokeRestart("muffleMessage")
[17:28:21.460]                     }
[17:28:21.460]                     else if (inherits(cond, "warning")) {
[17:28:21.460]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.460]                       if (muffled) 
[17:28:21.460]                         invokeRestart("muffleWarning")
[17:28:21.460]                     }
[17:28:21.460]                     else if (inherits(cond, "condition")) {
[17:28:21.460]                       if (!is.null(pattern)) {
[17:28:21.460]                         computeRestarts <- base::computeRestarts
[17:28:21.460]                         grepl <- base::grepl
[17:28:21.460]                         restarts <- computeRestarts(cond)
[17:28:21.460]                         for (restart in restarts) {
[17:28:21.460]                           name <- restart$name
[17:28:21.460]                           if (is.null(name)) 
[17:28:21.460]                             next
[17:28:21.460]                           if (!grepl(pattern, name)) 
[17:28:21.460]                             next
[17:28:21.460]                           invokeRestart(restart)
[17:28:21.460]                           muffled <- TRUE
[17:28:21.460]                           break
[17:28:21.460]                         }
[17:28:21.460]                       }
[17:28:21.460]                     }
[17:28:21.460]                     invisible(muffled)
[17:28:21.460]                   }
[17:28:21.460]                   muffleCondition(cond)
[17:28:21.460]                 })
[17:28:21.460]             }))
[17:28:21.460]             future::FutureResult(value = ...future.value$value, 
[17:28:21.460]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.460]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.460]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.460]                     ...future.globalenv.names))
[17:28:21.460]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.460]         }, condition = base::local({
[17:28:21.460]             c <- base::c
[17:28:21.460]             inherits <- base::inherits
[17:28:21.460]             invokeRestart <- base::invokeRestart
[17:28:21.460]             length <- base::length
[17:28:21.460]             list <- base::list
[17:28:21.460]             seq.int <- base::seq.int
[17:28:21.460]             signalCondition <- base::signalCondition
[17:28:21.460]             sys.calls <- base::sys.calls
[17:28:21.460]             `[[` <- base::`[[`
[17:28:21.460]             `+` <- base::`+`
[17:28:21.460]             `<<-` <- base::`<<-`
[17:28:21.460]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.460]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.460]                   3L)]
[17:28:21.460]             }
[17:28:21.460]             function(cond) {
[17:28:21.460]                 is_error <- inherits(cond, "error")
[17:28:21.460]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.460]                   NULL)
[17:28:21.460]                 if (is_error) {
[17:28:21.460]                   sessionInformation <- function() {
[17:28:21.460]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.460]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.460]                       search = base::search(), system = base::Sys.info())
[17:28:21.460]                   }
[17:28:21.460]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.460]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.460]                     cond$call), session = sessionInformation(), 
[17:28:21.460]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.460]                   signalCondition(cond)
[17:28:21.460]                 }
[17:28:21.460]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.460]                 "immediateCondition"))) {
[17:28:21.460]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.460]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.460]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.460]                   if (TRUE && !signal) {
[17:28:21.460]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.460]                     {
[17:28:21.460]                       inherits <- base::inherits
[17:28:21.460]                       invokeRestart <- base::invokeRestart
[17:28:21.460]                       is.null <- base::is.null
[17:28:21.460]                       muffled <- FALSE
[17:28:21.460]                       if (inherits(cond, "message")) {
[17:28:21.460]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.460]                         if (muffled) 
[17:28:21.460]                           invokeRestart("muffleMessage")
[17:28:21.460]                       }
[17:28:21.460]                       else if (inherits(cond, "warning")) {
[17:28:21.460]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.460]                         if (muffled) 
[17:28:21.460]                           invokeRestart("muffleWarning")
[17:28:21.460]                       }
[17:28:21.460]                       else if (inherits(cond, "condition")) {
[17:28:21.460]                         if (!is.null(pattern)) {
[17:28:21.460]                           computeRestarts <- base::computeRestarts
[17:28:21.460]                           grepl <- base::grepl
[17:28:21.460]                           restarts <- computeRestarts(cond)
[17:28:21.460]                           for (restart in restarts) {
[17:28:21.460]                             name <- restart$name
[17:28:21.460]                             if (is.null(name)) 
[17:28:21.460]                               next
[17:28:21.460]                             if (!grepl(pattern, name)) 
[17:28:21.460]                               next
[17:28:21.460]                             invokeRestart(restart)
[17:28:21.460]                             muffled <- TRUE
[17:28:21.460]                             break
[17:28:21.460]                           }
[17:28:21.460]                         }
[17:28:21.460]                       }
[17:28:21.460]                       invisible(muffled)
[17:28:21.460]                     }
[17:28:21.460]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.460]                   }
[17:28:21.460]                 }
[17:28:21.460]                 else {
[17:28:21.460]                   if (TRUE) {
[17:28:21.460]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.460]                     {
[17:28:21.460]                       inherits <- base::inherits
[17:28:21.460]                       invokeRestart <- base::invokeRestart
[17:28:21.460]                       is.null <- base::is.null
[17:28:21.460]                       muffled <- FALSE
[17:28:21.460]                       if (inherits(cond, "message")) {
[17:28:21.460]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.460]                         if (muffled) 
[17:28:21.460]                           invokeRestart("muffleMessage")
[17:28:21.460]                       }
[17:28:21.460]                       else if (inherits(cond, "warning")) {
[17:28:21.460]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.460]                         if (muffled) 
[17:28:21.460]                           invokeRestart("muffleWarning")
[17:28:21.460]                       }
[17:28:21.460]                       else if (inherits(cond, "condition")) {
[17:28:21.460]                         if (!is.null(pattern)) {
[17:28:21.460]                           computeRestarts <- base::computeRestarts
[17:28:21.460]                           grepl <- base::grepl
[17:28:21.460]                           restarts <- computeRestarts(cond)
[17:28:21.460]                           for (restart in restarts) {
[17:28:21.460]                             name <- restart$name
[17:28:21.460]                             if (is.null(name)) 
[17:28:21.460]                               next
[17:28:21.460]                             if (!grepl(pattern, name)) 
[17:28:21.460]                               next
[17:28:21.460]                             invokeRestart(restart)
[17:28:21.460]                             muffled <- TRUE
[17:28:21.460]                             break
[17:28:21.460]                           }
[17:28:21.460]                         }
[17:28:21.460]                       }
[17:28:21.460]                       invisible(muffled)
[17:28:21.460]                     }
[17:28:21.460]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.460]                   }
[17:28:21.460]                 }
[17:28:21.460]             }
[17:28:21.460]         }))
[17:28:21.460]     }, error = function(ex) {
[17:28:21.460]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.460]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.460]                 ...future.rng), started = ...future.startTime, 
[17:28:21.460]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.460]             version = "1.8"), class = "FutureResult")
[17:28:21.460]     }, finally = {
[17:28:21.460]         if (!identical(...future.workdir, getwd())) 
[17:28:21.460]             setwd(...future.workdir)
[17:28:21.460]         {
[17:28:21.460]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.460]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.460]             }
[17:28:21.460]             base::options(...future.oldOptions)
[17:28:21.460]             if (.Platform$OS.type == "windows") {
[17:28:21.460]                 old_names <- names(...future.oldEnvVars)
[17:28:21.460]                 envs <- base::Sys.getenv()
[17:28:21.460]                 names <- names(envs)
[17:28:21.460]                 common <- intersect(names, old_names)
[17:28:21.460]                 added <- setdiff(names, old_names)
[17:28:21.460]                 removed <- setdiff(old_names, names)
[17:28:21.460]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.460]                   envs[common]]
[17:28:21.460]                 NAMES <- toupper(changed)
[17:28:21.460]                 args <- list()
[17:28:21.460]                 for (kk in seq_along(NAMES)) {
[17:28:21.460]                   name <- changed[[kk]]
[17:28:21.460]                   NAME <- NAMES[[kk]]
[17:28:21.460]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.460]                     next
[17:28:21.460]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.460]                 }
[17:28:21.460]                 NAMES <- toupper(added)
[17:28:21.460]                 for (kk in seq_along(NAMES)) {
[17:28:21.460]                   name <- added[[kk]]
[17:28:21.460]                   NAME <- NAMES[[kk]]
[17:28:21.460]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.460]                     next
[17:28:21.460]                   args[[name]] <- ""
[17:28:21.460]                 }
[17:28:21.460]                 NAMES <- toupper(removed)
[17:28:21.460]                 for (kk in seq_along(NAMES)) {
[17:28:21.460]                   name <- removed[[kk]]
[17:28:21.460]                   NAME <- NAMES[[kk]]
[17:28:21.460]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.460]                     next
[17:28:21.460]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.460]                 }
[17:28:21.460]                 if (length(args) > 0) 
[17:28:21.460]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.460]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.460]             }
[17:28:21.460]             else {
[17:28:21.460]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.460]             }
[17:28:21.460]             {
[17:28:21.460]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.460]                   0L) {
[17:28:21.460]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.460]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.460]                   base::options(opts)
[17:28:21.460]                 }
[17:28:21.460]                 {
[17:28:21.460]                   {
[17:28:21.460]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.460]                     NULL
[17:28:21.460]                   }
[17:28:21.460]                   options(future.plan = NULL)
[17:28:21.460]                   if (is.na(NA_character_)) 
[17:28:21.460]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.460]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.460]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.460]                     .init = FALSE)
[17:28:21.460]                 }
[17:28:21.460]             }
[17:28:21.460]         }
[17:28:21.460]     })
[17:28:21.460]     if (TRUE) {
[17:28:21.460]         base::sink(type = "output", split = FALSE)
[17:28:21.460]         if (TRUE) {
[17:28:21.460]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.460]         }
[17:28:21.460]         else {
[17:28:21.460]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.460]         }
[17:28:21.460]         base::close(...future.stdout)
[17:28:21.460]         ...future.stdout <- NULL
[17:28:21.460]     }
[17:28:21.460]     ...future.result$conditions <- ...future.conditions
[17:28:21.460]     ...future.result$finished <- base::Sys.time()
[17:28:21.460]     ...future.result
[17:28:21.460] }
[17:28:21.465] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:21.476] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.477] - Validating connection of MultisessionFuture
[17:28:21.477] - received message: FutureResult
[17:28:21.477] - Received FutureResult
[17:28:21.477] - Erased future from FutureRegistry
[17:28:21.477] result() for ClusterFuture ...
[17:28:21.478] - result already collected: FutureResult
[17:28:21.478] result() for ClusterFuture ... done
[17:28:21.478] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:21.478] result() for ClusterFuture ...
[17:28:21.478] - result already collected: FutureResult
[17:28:21.479] result() for ClusterFuture ... done
[17:28:21.479] result() for ClusterFuture ...
[17:28:21.479] - result already collected: FutureResult
[17:28:21.479] result() for ClusterFuture ... done
[17:28:21.480] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:21.480] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:21.480] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:21.481] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:21.481] MultisessionFuture started
[17:28:21.482] - Launch lazy future ... done
[17:28:21.482] run() for 'MultisessionFuture' ... done
[17:28:21.482] result() for ClusterFuture ...
[17:28:21.482] - result already collected: FutureResult
[17:28:21.482] result() for ClusterFuture ... done
[17:28:21.483] result() for ClusterFuture ...
[17:28:21.483] - result already collected: FutureResult
[17:28:21.483] result() for ClusterFuture ... done
[17:28:21.483] result() for ClusterFuture ...
[17:28:21.483] - result already collected: FutureResult
[17:28:21.484] result() for ClusterFuture ... done
[17:28:21.484] result() for ClusterFuture ...
[17:28:21.484] - result already collected: FutureResult
[17:28:21.484] result() for ClusterFuture ... done
[17:28:21.484] result() for ClusterFuture ...
[17:28:21.484] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.485] - Validating connection of MultisessionFuture
[17:28:21.485] - received message: FutureResult
[17:28:21.485] - Received FutureResult
[17:28:21.485] - Erased future from FutureRegistry
[17:28:21.485] result() for ClusterFuture ...
[17:28:21.486] - result already collected: FutureResult
[17:28:21.486] result() for ClusterFuture ... done
[17:28:21.486] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:21.486] result() for ClusterFuture ... done
[17:28:21.486] result() for ClusterFuture ...
[17:28:21.487] - result already collected: FutureResult
[17:28:21.487] result() for ClusterFuture ... done
[17:28:21.487] result() for ClusterFuture ...
[17:28:21.487] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.487] - Validating connection of MultisessionFuture
[17:28:21.495] - received message: FutureResult
[17:28:21.496] - Received FutureResult
[17:28:21.496] - Erased future from FutureRegistry
[17:28:21.496] result() for ClusterFuture ...
[17:28:21.496] - result already collected: FutureResult
[17:28:21.496] result() for ClusterFuture ... done
[17:28:21.496] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:21.497] result() for ClusterFuture ... done
[17:28:21.497] result() for ClusterFuture ...
[17:28:21.497] - result already collected: FutureResult
[17:28:21.497] result() for ClusterFuture ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[17:28:21.498] getGlobalsAndPackages() ...
[17:28:21.498] Searching for globals...
[17:28:21.502] - globals found: [3] '{', 'sample', 'x'
[17:28:21.502] Searching for globals ... DONE
[17:28:21.502] Resolving globals: FALSE
[17:28:21.503] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.503] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.503] - globals: [1] 'x'
[17:28:21.504] 
[17:28:21.504] getGlobalsAndPackages() ... DONE
[17:28:21.504] run() for 'Future' ...
[17:28:21.504] - state: 'created'
[17:28:21.505] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.519] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.519] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.519]   - Field: 'node'
[17:28:21.519]   - Field: 'label'
[17:28:21.519]   - Field: 'local'
[17:28:21.520]   - Field: 'owner'
[17:28:21.520]   - Field: 'envir'
[17:28:21.520]   - Field: 'workers'
[17:28:21.520]   - Field: 'packages'
[17:28:21.520]   - Field: 'gc'
[17:28:21.520]   - Field: 'conditions'
[17:28:21.521]   - Field: 'persistent'
[17:28:21.521]   - Field: 'expr'
[17:28:21.521]   - Field: 'uuid'
[17:28:21.521]   - Field: 'seed'
[17:28:21.521]   - Field: 'version'
[17:28:21.522]   - Field: 'result'
[17:28:21.522]   - Field: 'asynchronous'
[17:28:21.522]   - Field: 'calls'
[17:28:21.522]   - Field: 'globals'
[17:28:21.522]   - Field: 'stdout'
[17:28:21.522]   - Field: 'earlySignal'
[17:28:21.523]   - Field: 'lazy'
[17:28:21.523]   - Field: 'state'
[17:28:21.523] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.523] - Launch lazy future ...
[17:28:21.523] Packages needed by the future expression (n = 0): <none>
[17:28:21.524] Packages needed by future strategies (n = 0): <none>
[17:28:21.524] {
[17:28:21.524]     {
[17:28:21.524]         {
[17:28:21.524]             ...future.startTime <- base::Sys.time()
[17:28:21.524]             {
[17:28:21.524]                 {
[17:28:21.524]                   {
[17:28:21.524]                     {
[17:28:21.524]                       base::local({
[17:28:21.524]                         has_future <- base::requireNamespace("future", 
[17:28:21.524]                           quietly = TRUE)
[17:28:21.524]                         if (has_future) {
[17:28:21.524]                           ns <- base::getNamespace("future")
[17:28:21.524]                           version <- ns[[".package"]][["version"]]
[17:28:21.524]                           if (is.null(version)) 
[17:28:21.524]                             version <- utils::packageVersion("future")
[17:28:21.524]                         }
[17:28:21.524]                         else {
[17:28:21.524]                           version <- NULL
[17:28:21.524]                         }
[17:28:21.524]                         if (!has_future || version < "1.8.0") {
[17:28:21.524]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.524]                             "", base::R.version$version.string), 
[17:28:21.524]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:21.524]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:21.524]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.524]                               "release", "version")], collapse = " "), 
[17:28:21.524]                             hostname = base::Sys.info()[["nodename"]])
[17:28:21.524]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.524]                             info)
[17:28:21.524]                           info <- base::paste(info, collapse = "; ")
[17:28:21.524]                           if (!has_future) {
[17:28:21.524]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.524]                               info)
[17:28:21.524]                           }
[17:28:21.524]                           else {
[17:28:21.524]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.524]                               info, version)
[17:28:21.524]                           }
[17:28:21.524]                           base::stop(msg)
[17:28:21.524]                         }
[17:28:21.524]                       })
[17:28:21.524]                     }
[17:28:21.524]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.524]                     base::options(mc.cores = 1L)
[17:28:21.524]                   }
[17:28:21.524]                   ...future.strategy.old <- future::plan("list")
[17:28:21.524]                   options(future.plan = NULL)
[17:28:21.524]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.524]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:21.524]                 }
[17:28:21.524]                 ...future.workdir <- getwd()
[17:28:21.524]             }
[17:28:21.524]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.524]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.524]         }
[17:28:21.524]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.524]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.524]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.524]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.524]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.524]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.524]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.524]             base::names(...future.oldOptions))
[17:28:21.524]     }
[17:28:21.524]     if (FALSE) {
[17:28:21.524]     }
[17:28:21.524]     else {
[17:28:21.524]         if (TRUE) {
[17:28:21.524]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.524]                 open = "w")
[17:28:21.524]         }
[17:28:21.524]         else {
[17:28:21.524]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.524]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.524]         }
[17:28:21.524]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.524]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.524]             base::sink(type = "output", split = FALSE)
[17:28:21.524]             base::close(...future.stdout)
[17:28:21.524]         }, add = TRUE)
[17:28:21.524]     }
[17:28:21.524]     ...future.frame <- base::sys.nframe()
[17:28:21.524]     ...future.conditions <- base::list()
[17:28:21.524]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.524]     if (FALSE) {
[17:28:21.524]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.524]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.524]     }
[17:28:21.524]     ...future.result <- base::tryCatch({
[17:28:21.524]         base::withCallingHandlers({
[17:28:21.524]             ...future.value <- base::withVisible(base::local({
[17:28:21.524]                 ...future.makeSendCondition <- base::local({
[17:28:21.524]                   sendCondition <- NULL
[17:28:21.524]                   function(frame = 1L) {
[17:28:21.524]                     if (is.function(sendCondition)) 
[17:28:21.524]                       return(sendCondition)
[17:28:21.524]                     ns <- getNamespace("parallel")
[17:28:21.524]                     if (exists("sendData", mode = "function", 
[17:28:21.524]                       envir = ns)) {
[17:28:21.524]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.524]                         envir = ns)
[17:28:21.524]                       envir <- sys.frame(frame)
[17:28:21.524]                       master <- NULL
[17:28:21.524]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.524]                         !identical(envir, emptyenv())) {
[17:28:21.524]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.524]                           inherits = FALSE)) {
[17:28:21.524]                           master <- get("master", mode = "list", 
[17:28:21.524]                             envir = envir, inherits = FALSE)
[17:28:21.524]                           if (inherits(master, c("SOCKnode", 
[17:28:21.524]                             "SOCK0node"))) {
[17:28:21.524]                             sendCondition <<- function(cond) {
[17:28:21.524]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.524]                                 success = TRUE)
[17:28:21.524]                               parallel_sendData(master, data)
[17:28:21.524]                             }
[17:28:21.524]                             return(sendCondition)
[17:28:21.524]                           }
[17:28:21.524]                         }
[17:28:21.524]                         frame <- frame + 1L
[17:28:21.524]                         envir <- sys.frame(frame)
[17:28:21.524]                       }
[17:28:21.524]                     }
[17:28:21.524]                     sendCondition <<- function(cond) NULL
[17:28:21.524]                   }
[17:28:21.524]                 })
[17:28:21.524]                 withCallingHandlers({
[17:28:21.524]                   {
[17:28:21.524]                     sample(x, size = 1L)
[17:28:21.524]                   }
[17:28:21.524]                 }, immediateCondition = function(cond) {
[17:28:21.524]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.524]                   sendCondition(cond)
[17:28:21.524]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.524]                   {
[17:28:21.524]                     inherits <- base::inherits
[17:28:21.524]                     invokeRestart <- base::invokeRestart
[17:28:21.524]                     is.null <- base::is.null
[17:28:21.524]                     muffled <- FALSE
[17:28:21.524]                     if (inherits(cond, "message")) {
[17:28:21.524]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.524]                       if (muffled) 
[17:28:21.524]                         invokeRestart("muffleMessage")
[17:28:21.524]                     }
[17:28:21.524]                     else if (inherits(cond, "warning")) {
[17:28:21.524]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.524]                       if (muffled) 
[17:28:21.524]                         invokeRestart("muffleWarning")
[17:28:21.524]                     }
[17:28:21.524]                     else if (inherits(cond, "condition")) {
[17:28:21.524]                       if (!is.null(pattern)) {
[17:28:21.524]                         computeRestarts <- base::computeRestarts
[17:28:21.524]                         grepl <- base::grepl
[17:28:21.524]                         restarts <- computeRestarts(cond)
[17:28:21.524]                         for (restart in restarts) {
[17:28:21.524]                           name <- restart$name
[17:28:21.524]                           if (is.null(name)) 
[17:28:21.524]                             next
[17:28:21.524]                           if (!grepl(pattern, name)) 
[17:28:21.524]                             next
[17:28:21.524]                           invokeRestart(restart)
[17:28:21.524]                           muffled <- TRUE
[17:28:21.524]                           break
[17:28:21.524]                         }
[17:28:21.524]                       }
[17:28:21.524]                     }
[17:28:21.524]                     invisible(muffled)
[17:28:21.524]                   }
[17:28:21.524]                   muffleCondition(cond)
[17:28:21.524]                 })
[17:28:21.524]             }))
[17:28:21.524]             future::FutureResult(value = ...future.value$value, 
[17:28:21.524]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.524]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.524]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.524]                     ...future.globalenv.names))
[17:28:21.524]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.524]         }, condition = base::local({
[17:28:21.524]             c <- base::c
[17:28:21.524]             inherits <- base::inherits
[17:28:21.524]             invokeRestart <- base::invokeRestart
[17:28:21.524]             length <- base::length
[17:28:21.524]             list <- base::list
[17:28:21.524]             seq.int <- base::seq.int
[17:28:21.524]             signalCondition <- base::signalCondition
[17:28:21.524]             sys.calls <- base::sys.calls
[17:28:21.524]             `[[` <- base::`[[`
[17:28:21.524]             `+` <- base::`+`
[17:28:21.524]             `<<-` <- base::`<<-`
[17:28:21.524]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.524]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.524]                   3L)]
[17:28:21.524]             }
[17:28:21.524]             function(cond) {
[17:28:21.524]                 is_error <- inherits(cond, "error")
[17:28:21.524]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.524]                   NULL)
[17:28:21.524]                 if (is_error) {
[17:28:21.524]                   sessionInformation <- function() {
[17:28:21.524]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.524]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.524]                       search = base::search(), system = base::Sys.info())
[17:28:21.524]                   }
[17:28:21.524]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.524]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.524]                     cond$call), session = sessionInformation(), 
[17:28:21.524]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.524]                   signalCondition(cond)
[17:28:21.524]                 }
[17:28:21.524]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.524]                 "immediateCondition"))) {
[17:28:21.524]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.524]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.524]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.524]                   if (TRUE && !signal) {
[17:28:21.524]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.524]                     {
[17:28:21.524]                       inherits <- base::inherits
[17:28:21.524]                       invokeRestart <- base::invokeRestart
[17:28:21.524]                       is.null <- base::is.null
[17:28:21.524]                       muffled <- FALSE
[17:28:21.524]                       if (inherits(cond, "message")) {
[17:28:21.524]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.524]                         if (muffled) 
[17:28:21.524]                           invokeRestart("muffleMessage")
[17:28:21.524]                       }
[17:28:21.524]                       else if (inherits(cond, "warning")) {
[17:28:21.524]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.524]                         if (muffled) 
[17:28:21.524]                           invokeRestart("muffleWarning")
[17:28:21.524]                       }
[17:28:21.524]                       else if (inherits(cond, "condition")) {
[17:28:21.524]                         if (!is.null(pattern)) {
[17:28:21.524]                           computeRestarts <- base::computeRestarts
[17:28:21.524]                           grepl <- base::grepl
[17:28:21.524]                           restarts <- computeRestarts(cond)
[17:28:21.524]                           for (restart in restarts) {
[17:28:21.524]                             name <- restart$name
[17:28:21.524]                             if (is.null(name)) 
[17:28:21.524]                               next
[17:28:21.524]                             if (!grepl(pattern, name)) 
[17:28:21.524]                               next
[17:28:21.524]                             invokeRestart(restart)
[17:28:21.524]                             muffled <- TRUE
[17:28:21.524]                             break
[17:28:21.524]                           }
[17:28:21.524]                         }
[17:28:21.524]                       }
[17:28:21.524]                       invisible(muffled)
[17:28:21.524]                     }
[17:28:21.524]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.524]                   }
[17:28:21.524]                 }
[17:28:21.524]                 else {
[17:28:21.524]                   if (TRUE) {
[17:28:21.524]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.524]                     {
[17:28:21.524]                       inherits <- base::inherits
[17:28:21.524]                       invokeRestart <- base::invokeRestart
[17:28:21.524]                       is.null <- base::is.null
[17:28:21.524]                       muffled <- FALSE
[17:28:21.524]                       if (inherits(cond, "message")) {
[17:28:21.524]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.524]                         if (muffled) 
[17:28:21.524]                           invokeRestart("muffleMessage")
[17:28:21.524]                       }
[17:28:21.524]                       else if (inherits(cond, "warning")) {
[17:28:21.524]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.524]                         if (muffled) 
[17:28:21.524]                           invokeRestart("muffleWarning")
[17:28:21.524]                       }
[17:28:21.524]                       else if (inherits(cond, "condition")) {
[17:28:21.524]                         if (!is.null(pattern)) {
[17:28:21.524]                           computeRestarts <- base::computeRestarts
[17:28:21.524]                           grepl <- base::grepl
[17:28:21.524]                           restarts <- computeRestarts(cond)
[17:28:21.524]                           for (restart in restarts) {
[17:28:21.524]                             name <- restart$name
[17:28:21.524]                             if (is.null(name)) 
[17:28:21.524]                               next
[17:28:21.524]                             if (!grepl(pattern, name)) 
[17:28:21.524]                               next
[17:28:21.524]                             invokeRestart(restart)
[17:28:21.524]                             muffled <- TRUE
[17:28:21.524]                             break
[17:28:21.524]                           }
[17:28:21.524]                         }
[17:28:21.524]                       }
[17:28:21.524]                       invisible(muffled)
[17:28:21.524]                     }
[17:28:21.524]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.524]                   }
[17:28:21.524]                 }
[17:28:21.524]             }
[17:28:21.524]         }))
[17:28:21.524]     }, error = function(ex) {
[17:28:21.524]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.524]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.524]                 ...future.rng), started = ...future.startTime, 
[17:28:21.524]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.524]             version = "1.8"), class = "FutureResult")
[17:28:21.524]     }, finally = {
[17:28:21.524]         if (!identical(...future.workdir, getwd())) 
[17:28:21.524]             setwd(...future.workdir)
[17:28:21.524]         {
[17:28:21.524]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.524]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.524]             }
[17:28:21.524]             base::options(...future.oldOptions)
[17:28:21.524]             if (.Platform$OS.type == "windows") {
[17:28:21.524]                 old_names <- names(...future.oldEnvVars)
[17:28:21.524]                 envs <- base::Sys.getenv()
[17:28:21.524]                 names <- names(envs)
[17:28:21.524]                 common <- intersect(names, old_names)
[17:28:21.524]                 added <- setdiff(names, old_names)
[17:28:21.524]                 removed <- setdiff(old_names, names)
[17:28:21.524]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.524]                   envs[common]]
[17:28:21.524]                 NAMES <- toupper(changed)
[17:28:21.524]                 args <- list()
[17:28:21.524]                 for (kk in seq_along(NAMES)) {
[17:28:21.524]                   name <- changed[[kk]]
[17:28:21.524]                   NAME <- NAMES[[kk]]
[17:28:21.524]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.524]                     next
[17:28:21.524]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.524]                 }
[17:28:21.524]                 NAMES <- toupper(added)
[17:28:21.524]                 for (kk in seq_along(NAMES)) {
[17:28:21.524]                   name <- added[[kk]]
[17:28:21.524]                   NAME <- NAMES[[kk]]
[17:28:21.524]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.524]                     next
[17:28:21.524]                   args[[name]] <- ""
[17:28:21.524]                 }
[17:28:21.524]                 NAMES <- toupper(removed)
[17:28:21.524]                 for (kk in seq_along(NAMES)) {
[17:28:21.524]                   name <- removed[[kk]]
[17:28:21.524]                   NAME <- NAMES[[kk]]
[17:28:21.524]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.524]                     next
[17:28:21.524]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.524]                 }
[17:28:21.524]                 if (length(args) > 0) 
[17:28:21.524]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.524]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.524]             }
[17:28:21.524]             else {
[17:28:21.524]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.524]             }
[17:28:21.524]             {
[17:28:21.524]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.524]                   0L) {
[17:28:21.524]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.524]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.524]                   base::options(opts)
[17:28:21.524]                 }
[17:28:21.524]                 {
[17:28:21.524]                   {
[17:28:21.524]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.524]                     NULL
[17:28:21.524]                   }
[17:28:21.524]                   options(future.plan = NULL)
[17:28:21.524]                   if (is.na(NA_character_)) 
[17:28:21.524]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.524]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.524]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.524]                     .init = FALSE)
[17:28:21.524]                 }
[17:28:21.524]             }
[17:28:21.524]         }
[17:28:21.524]     })
[17:28:21.524]     if (TRUE) {
[17:28:21.524]         base::sink(type = "output", split = FALSE)
[17:28:21.524]         if (TRUE) {
[17:28:21.524]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.524]         }
[17:28:21.524]         else {
[17:28:21.524]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.524]         }
[17:28:21.524]         base::close(...future.stdout)
[17:28:21.524]         ...future.stdout <- NULL
[17:28:21.524]     }
[17:28:21.524]     ...future.result$conditions <- ...future.conditions
[17:28:21.524]     ...future.result$finished <- base::Sys.time()
[17:28:21.524]     ...future.result
[17:28:21.524] }
[17:28:21.529] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:21.529] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:21.530] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:21.530] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:21.531] MultisessionFuture started
[17:28:21.531] - Launch lazy future ... done
[17:28:21.531] run() for 'MultisessionFuture' ... done
[17:28:21.532] getGlobalsAndPackages() ...
[17:28:21.532] Searching for globals...
[17:28:21.533] - globals found: [3] '{', 'sample', 'x'
[17:28:21.533] Searching for globals ... DONE
[17:28:21.533] Resolving globals: FALSE
[17:28:21.534] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.534] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.535] - globals: [1] 'x'
[17:28:21.535] 
[17:28:21.535] getGlobalsAndPackages() ... DONE
[17:28:21.535] run() for 'Future' ...
[17:28:21.535] - state: 'created'
[17:28:21.536] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.550] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.550] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.551]   - Field: 'node'
[17:28:21.551]   - Field: 'label'
[17:28:21.551]   - Field: 'local'
[17:28:21.551]   - Field: 'owner'
[17:28:21.551]   - Field: 'envir'
[17:28:21.551]   - Field: 'workers'
[17:28:21.552]   - Field: 'packages'
[17:28:21.552]   - Field: 'gc'
[17:28:21.552]   - Field: 'conditions'
[17:28:21.552]   - Field: 'persistent'
[17:28:21.552]   - Field: 'expr'
[17:28:21.553]   - Field: 'uuid'
[17:28:21.553]   - Field: 'seed'
[17:28:21.553]   - Field: 'version'
[17:28:21.553]   - Field: 'result'
[17:28:21.553]   - Field: 'asynchronous'
[17:28:21.553]   - Field: 'calls'
[17:28:21.554]   - Field: 'globals'
[17:28:21.554]   - Field: 'stdout'
[17:28:21.554]   - Field: 'earlySignal'
[17:28:21.554]   - Field: 'lazy'
[17:28:21.554]   - Field: 'state'
[17:28:21.555] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.555] - Launch lazy future ...
[17:28:21.555] Packages needed by the future expression (n = 0): <none>
[17:28:21.555] Packages needed by future strategies (n = 0): <none>
[17:28:21.556] {
[17:28:21.556]     {
[17:28:21.556]         {
[17:28:21.556]             ...future.startTime <- base::Sys.time()
[17:28:21.556]             {
[17:28:21.556]                 {
[17:28:21.556]                   {
[17:28:21.556]                     {
[17:28:21.556]                       base::local({
[17:28:21.556]                         has_future <- base::requireNamespace("future", 
[17:28:21.556]                           quietly = TRUE)
[17:28:21.556]                         if (has_future) {
[17:28:21.556]                           ns <- base::getNamespace("future")
[17:28:21.556]                           version <- ns[[".package"]][["version"]]
[17:28:21.556]                           if (is.null(version)) 
[17:28:21.556]                             version <- utils::packageVersion("future")
[17:28:21.556]                         }
[17:28:21.556]                         else {
[17:28:21.556]                           version <- NULL
[17:28:21.556]                         }
[17:28:21.556]                         if (!has_future || version < "1.8.0") {
[17:28:21.556]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.556]                             "", base::R.version$version.string), 
[17:28:21.556]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:21.556]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:21.556]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.556]                               "release", "version")], collapse = " "), 
[17:28:21.556]                             hostname = base::Sys.info()[["nodename"]])
[17:28:21.556]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.556]                             info)
[17:28:21.556]                           info <- base::paste(info, collapse = "; ")
[17:28:21.556]                           if (!has_future) {
[17:28:21.556]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.556]                               info)
[17:28:21.556]                           }
[17:28:21.556]                           else {
[17:28:21.556]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.556]                               info, version)
[17:28:21.556]                           }
[17:28:21.556]                           base::stop(msg)
[17:28:21.556]                         }
[17:28:21.556]                       })
[17:28:21.556]                     }
[17:28:21.556]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.556]                     base::options(mc.cores = 1L)
[17:28:21.556]                   }
[17:28:21.556]                   ...future.strategy.old <- future::plan("list")
[17:28:21.556]                   options(future.plan = NULL)
[17:28:21.556]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.556]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:21.556]                 }
[17:28:21.556]                 ...future.workdir <- getwd()
[17:28:21.556]             }
[17:28:21.556]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.556]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.556]         }
[17:28:21.556]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.556]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.556]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.556]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.556]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.556]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.556]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.556]             base::names(...future.oldOptions))
[17:28:21.556]     }
[17:28:21.556]     if (FALSE) {
[17:28:21.556]     }
[17:28:21.556]     else {
[17:28:21.556]         if (TRUE) {
[17:28:21.556]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.556]                 open = "w")
[17:28:21.556]         }
[17:28:21.556]         else {
[17:28:21.556]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.556]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.556]         }
[17:28:21.556]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.556]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.556]             base::sink(type = "output", split = FALSE)
[17:28:21.556]             base::close(...future.stdout)
[17:28:21.556]         }, add = TRUE)
[17:28:21.556]     }
[17:28:21.556]     ...future.frame <- base::sys.nframe()
[17:28:21.556]     ...future.conditions <- base::list()
[17:28:21.556]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.556]     if (FALSE) {
[17:28:21.556]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.556]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.556]     }
[17:28:21.556]     ...future.result <- base::tryCatch({
[17:28:21.556]         base::withCallingHandlers({
[17:28:21.556]             ...future.value <- base::withVisible(base::local({
[17:28:21.556]                 ...future.makeSendCondition <- base::local({
[17:28:21.556]                   sendCondition <- NULL
[17:28:21.556]                   function(frame = 1L) {
[17:28:21.556]                     if (is.function(sendCondition)) 
[17:28:21.556]                       return(sendCondition)
[17:28:21.556]                     ns <- getNamespace("parallel")
[17:28:21.556]                     if (exists("sendData", mode = "function", 
[17:28:21.556]                       envir = ns)) {
[17:28:21.556]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.556]                         envir = ns)
[17:28:21.556]                       envir <- sys.frame(frame)
[17:28:21.556]                       master <- NULL
[17:28:21.556]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.556]                         !identical(envir, emptyenv())) {
[17:28:21.556]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.556]                           inherits = FALSE)) {
[17:28:21.556]                           master <- get("master", mode = "list", 
[17:28:21.556]                             envir = envir, inherits = FALSE)
[17:28:21.556]                           if (inherits(master, c("SOCKnode", 
[17:28:21.556]                             "SOCK0node"))) {
[17:28:21.556]                             sendCondition <<- function(cond) {
[17:28:21.556]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.556]                                 success = TRUE)
[17:28:21.556]                               parallel_sendData(master, data)
[17:28:21.556]                             }
[17:28:21.556]                             return(sendCondition)
[17:28:21.556]                           }
[17:28:21.556]                         }
[17:28:21.556]                         frame <- frame + 1L
[17:28:21.556]                         envir <- sys.frame(frame)
[17:28:21.556]                       }
[17:28:21.556]                     }
[17:28:21.556]                     sendCondition <<- function(cond) NULL
[17:28:21.556]                   }
[17:28:21.556]                 })
[17:28:21.556]                 withCallingHandlers({
[17:28:21.556]                   {
[17:28:21.556]                     sample(x, size = 1L)
[17:28:21.556]                   }
[17:28:21.556]                 }, immediateCondition = function(cond) {
[17:28:21.556]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.556]                   sendCondition(cond)
[17:28:21.556]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.556]                   {
[17:28:21.556]                     inherits <- base::inherits
[17:28:21.556]                     invokeRestart <- base::invokeRestart
[17:28:21.556]                     is.null <- base::is.null
[17:28:21.556]                     muffled <- FALSE
[17:28:21.556]                     if (inherits(cond, "message")) {
[17:28:21.556]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.556]                       if (muffled) 
[17:28:21.556]                         invokeRestart("muffleMessage")
[17:28:21.556]                     }
[17:28:21.556]                     else if (inherits(cond, "warning")) {
[17:28:21.556]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.556]                       if (muffled) 
[17:28:21.556]                         invokeRestart("muffleWarning")
[17:28:21.556]                     }
[17:28:21.556]                     else if (inherits(cond, "condition")) {
[17:28:21.556]                       if (!is.null(pattern)) {
[17:28:21.556]                         computeRestarts <- base::computeRestarts
[17:28:21.556]                         grepl <- base::grepl
[17:28:21.556]                         restarts <- computeRestarts(cond)
[17:28:21.556]                         for (restart in restarts) {
[17:28:21.556]                           name <- restart$name
[17:28:21.556]                           if (is.null(name)) 
[17:28:21.556]                             next
[17:28:21.556]                           if (!grepl(pattern, name)) 
[17:28:21.556]                             next
[17:28:21.556]                           invokeRestart(restart)
[17:28:21.556]                           muffled <- TRUE
[17:28:21.556]                           break
[17:28:21.556]                         }
[17:28:21.556]                       }
[17:28:21.556]                     }
[17:28:21.556]                     invisible(muffled)
[17:28:21.556]                   }
[17:28:21.556]                   muffleCondition(cond)
[17:28:21.556]                 })
[17:28:21.556]             }))
[17:28:21.556]             future::FutureResult(value = ...future.value$value, 
[17:28:21.556]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.556]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.556]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.556]                     ...future.globalenv.names))
[17:28:21.556]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.556]         }, condition = base::local({
[17:28:21.556]             c <- base::c
[17:28:21.556]             inherits <- base::inherits
[17:28:21.556]             invokeRestart <- base::invokeRestart
[17:28:21.556]             length <- base::length
[17:28:21.556]             list <- base::list
[17:28:21.556]             seq.int <- base::seq.int
[17:28:21.556]             signalCondition <- base::signalCondition
[17:28:21.556]             sys.calls <- base::sys.calls
[17:28:21.556]             `[[` <- base::`[[`
[17:28:21.556]             `+` <- base::`+`
[17:28:21.556]             `<<-` <- base::`<<-`
[17:28:21.556]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.556]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.556]                   3L)]
[17:28:21.556]             }
[17:28:21.556]             function(cond) {
[17:28:21.556]                 is_error <- inherits(cond, "error")
[17:28:21.556]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.556]                   NULL)
[17:28:21.556]                 if (is_error) {
[17:28:21.556]                   sessionInformation <- function() {
[17:28:21.556]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.556]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.556]                       search = base::search(), system = base::Sys.info())
[17:28:21.556]                   }
[17:28:21.556]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.556]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.556]                     cond$call), session = sessionInformation(), 
[17:28:21.556]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.556]                   signalCondition(cond)
[17:28:21.556]                 }
[17:28:21.556]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.556]                 "immediateCondition"))) {
[17:28:21.556]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.556]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.556]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.556]                   if (TRUE && !signal) {
[17:28:21.556]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.556]                     {
[17:28:21.556]                       inherits <- base::inherits
[17:28:21.556]                       invokeRestart <- base::invokeRestart
[17:28:21.556]                       is.null <- base::is.null
[17:28:21.556]                       muffled <- FALSE
[17:28:21.556]                       if (inherits(cond, "message")) {
[17:28:21.556]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.556]                         if (muffled) 
[17:28:21.556]                           invokeRestart("muffleMessage")
[17:28:21.556]                       }
[17:28:21.556]                       else if (inherits(cond, "warning")) {
[17:28:21.556]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.556]                         if (muffled) 
[17:28:21.556]                           invokeRestart("muffleWarning")
[17:28:21.556]                       }
[17:28:21.556]                       else if (inherits(cond, "condition")) {
[17:28:21.556]                         if (!is.null(pattern)) {
[17:28:21.556]                           computeRestarts <- base::computeRestarts
[17:28:21.556]                           grepl <- base::grepl
[17:28:21.556]                           restarts <- computeRestarts(cond)
[17:28:21.556]                           for (restart in restarts) {
[17:28:21.556]                             name <- restart$name
[17:28:21.556]                             if (is.null(name)) 
[17:28:21.556]                               next
[17:28:21.556]                             if (!grepl(pattern, name)) 
[17:28:21.556]                               next
[17:28:21.556]                             invokeRestart(restart)
[17:28:21.556]                             muffled <- TRUE
[17:28:21.556]                             break
[17:28:21.556]                           }
[17:28:21.556]                         }
[17:28:21.556]                       }
[17:28:21.556]                       invisible(muffled)
[17:28:21.556]                     }
[17:28:21.556]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.556]                   }
[17:28:21.556]                 }
[17:28:21.556]                 else {
[17:28:21.556]                   if (TRUE) {
[17:28:21.556]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.556]                     {
[17:28:21.556]                       inherits <- base::inherits
[17:28:21.556]                       invokeRestart <- base::invokeRestart
[17:28:21.556]                       is.null <- base::is.null
[17:28:21.556]                       muffled <- FALSE
[17:28:21.556]                       if (inherits(cond, "message")) {
[17:28:21.556]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.556]                         if (muffled) 
[17:28:21.556]                           invokeRestart("muffleMessage")
[17:28:21.556]                       }
[17:28:21.556]                       else if (inherits(cond, "warning")) {
[17:28:21.556]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.556]                         if (muffled) 
[17:28:21.556]                           invokeRestart("muffleWarning")
[17:28:21.556]                       }
[17:28:21.556]                       else if (inherits(cond, "condition")) {
[17:28:21.556]                         if (!is.null(pattern)) {
[17:28:21.556]                           computeRestarts <- base::computeRestarts
[17:28:21.556]                           grepl <- base::grepl
[17:28:21.556]                           restarts <- computeRestarts(cond)
[17:28:21.556]                           for (restart in restarts) {
[17:28:21.556]                             name <- restart$name
[17:28:21.556]                             if (is.null(name)) 
[17:28:21.556]                               next
[17:28:21.556]                             if (!grepl(pattern, name)) 
[17:28:21.556]                               next
[17:28:21.556]                             invokeRestart(restart)
[17:28:21.556]                             muffled <- TRUE
[17:28:21.556]                             break
[17:28:21.556]                           }
[17:28:21.556]                         }
[17:28:21.556]                       }
[17:28:21.556]                       invisible(muffled)
[17:28:21.556]                     }
[17:28:21.556]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.556]                   }
[17:28:21.556]                 }
[17:28:21.556]             }
[17:28:21.556]         }))
[17:28:21.556]     }, error = function(ex) {
[17:28:21.556]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.556]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.556]                 ...future.rng), started = ...future.startTime, 
[17:28:21.556]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.556]             version = "1.8"), class = "FutureResult")
[17:28:21.556]     }, finally = {
[17:28:21.556]         if (!identical(...future.workdir, getwd())) 
[17:28:21.556]             setwd(...future.workdir)
[17:28:21.556]         {
[17:28:21.556]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.556]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.556]             }
[17:28:21.556]             base::options(...future.oldOptions)
[17:28:21.556]             if (.Platform$OS.type == "windows") {
[17:28:21.556]                 old_names <- names(...future.oldEnvVars)
[17:28:21.556]                 envs <- base::Sys.getenv()
[17:28:21.556]                 names <- names(envs)
[17:28:21.556]                 common <- intersect(names, old_names)
[17:28:21.556]                 added <- setdiff(names, old_names)
[17:28:21.556]                 removed <- setdiff(old_names, names)
[17:28:21.556]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.556]                   envs[common]]
[17:28:21.556]                 NAMES <- toupper(changed)
[17:28:21.556]                 args <- list()
[17:28:21.556]                 for (kk in seq_along(NAMES)) {
[17:28:21.556]                   name <- changed[[kk]]
[17:28:21.556]                   NAME <- NAMES[[kk]]
[17:28:21.556]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.556]                     next
[17:28:21.556]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.556]                 }
[17:28:21.556]                 NAMES <- toupper(added)
[17:28:21.556]                 for (kk in seq_along(NAMES)) {
[17:28:21.556]                   name <- added[[kk]]
[17:28:21.556]                   NAME <- NAMES[[kk]]
[17:28:21.556]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.556]                     next
[17:28:21.556]                   args[[name]] <- ""
[17:28:21.556]                 }
[17:28:21.556]                 NAMES <- toupper(removed)
[17:28:21.556]                 for (kk in seq_along(NAMES)) {
[17:28:21.556]                   name <- removed[[kk]]
[17:28:21.556]                   NAME <- NAMES[[kk]]
[17:28:21.556]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.556]                     next
[17:28:21.556]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.556]                 }
[17:28:21.556]                 if (length(args) > 0) 
[17:28:21.556]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.556]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.556]             }
[17:28:21.556]             else {
[17:28:21.556]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.556]             }
[17:28:21.556]             {
[17:28:21.556]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.556]                   0L) {
[17:28:21.556]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.556]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.556]                   base::options(opts)
[17:28:21.556]                 }
[17:28:21.556]                 {
[17:28:21.556]                   {
[17:28:21.556]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.556]                     NULL
[17:28:21.556]                   }
[17:28:21.556]                   options(future.plan = NULL)
[17:28:21.556]                   if (is.na(NA_character_)) 
[17:28:21.556]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.556]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.556]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.556]                     .init = FALSE)
[17:28:21.556]                 }
[17:28:21.556]             }
[17:28:21.556]         }
[17:28:21.556]     })
[17:28:21.556]     if (TRUE) {
[17:28:21.556]         base::sink(type = "output", split = FALSE)
[17:28:21.556]         if (TRUE) {
[17:28:21.556]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.556]         }
[17:28:21.556]         else {
[17:28:21.556]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.556]         }
[17:28:21.556]         base::close(...future.stdout)
[17:28:21.556]         ...future.stdout <- NULL
[17:28:21.556]     }
[17:28:21.556]     ...future.result$conditions <- ...future.conditions
[17:28:21.556]     ...future.result$finished <- base::Sys.time()
[17:28:21.556]     ...future.result
[17:28:21.556] }
[17:28:21.561] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:21.561] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:21.562] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:21.562] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:21.562] MultisessionFuture started
[17:28:21.563] - Launch lazy future ... done
[17:28:21.563] run() for 'MultisessionFuture' ... done
[17:28:21.563] getGlobalsAndPackages() ...
[17:28:21.564] Searching for globals...
[17:28:21.565] - globals found: [3] '{', 'sample', 'x'
[17:28:21.565] Searching for globals ... DONE
[17:28:21.565] Resolving globals: FALSE
[17:28:21.566] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.566] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.566] - globals: [1] 'x'
[17:28:21.566] 
[17:28:21.567] getGlobalsAndPackages() ... DONE
[17:28:21.567] run() for 'Future' ...
[17:28:21.567] - state: 'created'
[17:28:21.567] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.581] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.581] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.581]   - Field: 'node'
[17:28:21.581]   - Field: 'label'
[17:28:21.582]   - Field: 'local'
[17:28:21.582]   - Field: 'owner'
[17:28:21.582]   - Field: 'envir'
[17:28:21.582]   - Field: 'workers'
[17:28:21.582]   - Field: 'packages'
[17:28:21.583]   - Field: 'gc'
[17:28:21.583]   - Field: 'conditions'
[17:28:21.583]   - Field: 'persistent'
[17:28:21.583]   - Field: 'expr'
[17:28:21.583]   - Field: 'uuid'
[17:28:21.583]   - Field: 'seed'
[17:28:21.584]   - Field: 'version'
[17:28:21.584]   - Field: 'result'
[17:28:21.584]   - Field: 'asynchronous'
[17:28:21.584]   - Field: 'calls'
[17:28:21.584]   - Field: 'globals'
[17:28:21.585]   - Field: 'stdout'
[17:28:21.585]   - Field: 'earlySignal'
[17:28:21.585]   - Field: 'lazy'
[17:28:21.585]   - Field: 'state'
[17:28:21.585] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.585] - Launch lazy future ...
[17:28:21.586] Packages needed by the future expression (n = 0): <none>
[17:28:21.586] Packages needed by future strategies (n = 0): <none>
[17:28:21.587] {
[17:28:21.587]     {
[17:28:21.587]         {
[17:28:21.587]             ...future.startTime <- base::Sys.time()
[17:28:21.587]             {
[17:28:21.587]                 {
[17:28:21.587]                   {
[17:28:21.587]                     {
[17:28:21.587]                       base::local({
[17:28:21.587]                         has_future <- base::requireNamespace("future", 
[17:28:21.587]                           quietly = TRUE)
[17:28:21.587]                         if (has_future) {
[17:28:21.587]                           ns <- base::getNamespace("future")
[17:28:21.587]                           version <- ns[[".package"]][["version"]]
[17:28:21.587]                           if (is.null(version)) 
[17:28:21.587]                             version <- utils::packageVersion("future")
[17:28:21.587]                         }
[17:28:21.587]                         else {
[17:28:21.587]                           version <- NULL
[17:28:21.587]                         }
[17:28:21.587]                         if (!has_future || version < "1.8.0") {
[17:28:21.587]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.587]                             "", base::R.version$version.string), 
[17:28:21.587]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:21.587]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:21.587]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.587]                               "release", "version")], collapse = " "), 
[17:28:21.587]                             hostname = base::Sys.info()[["nodename"]])
[17:28:21.587]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.587]                             info)
[17:28:21.587]                           info <- base::paste(info, collapse = "; ")
[17:28:21.587]                           if (!has_future) {
[17:28:21.587]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.587]                               info)
[17:28:21.587]                           }
[17:28:21.587]                           else {
[17:28:21.587]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.587]                               info, version)
[17:28:21.587]                           }
[17:28:21.587]                           base::stop(msg)
[17:28:21.587]                         }
[17:28:21.587]                       })
[17:28:21.587]                     }
[17:28:21.587]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.587]                     base::options(mc.cores = 1L)
[17:28:21.587]                   }
[17:28:21.587]                   ...future.strategy.old <- future::plan("list")
[17:28:21.587]                   options(future.plan = NULL)
[17:28:21.587]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.587]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:21.587]                 }
[17:28:21.587]                 ...future.workdir <- getwd()
[17:28:21.587]             }
[17:28:21.587]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.587]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.587]         }
[17:28:21.587]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.587]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.587]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.587]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.587]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.587]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.587]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.587]             base::names(...future.oldOptions))
[17:28:21.587]     }
[17:28:21.587]     if (FALSE) {
[17:28:21.587]     }
[17:28:21.587]     else {
[17:28:21.587]         if (TRUE) {
[17:28:21.587]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.587]                 open = "w")
[17:28:21.587]         }
[17:28:21.587]         else {
[17:28:21.587]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.587]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.587]         }
[17:28:21.587]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.587]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.587]             base::sink(type = "output", split = FALSE)
[17:28:21.587]             base::close(...future.stdout)
[17:28:21.587]         }, add = TRUE)
[17:28:21.587]     }
[17:28:21.587]     ...future.frame <- base::sys.nframe()
[17:28:21.587]     ...future.conditions <- base::list()
[17:28:21.587]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.587]     if (FALSE) {
[17:28:21.587]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.587]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.587]     }
[17:28:21.587]     ...future.result <- base::tryCatch({
[17:28:21.587]         base::withCallingHandlers({
[17:28:21.587]             ...future.value <- base::withVisible(base::local({
[17:28:21.587]                 ...future.makeSendCondition <- base::local({
[17:28:21.587]                   sendCondition <- NULL
[17:28:21.587]                   function(frame = 1L) {
[17:28:21.587]                     if (is.function(sendCondition)) 
[17:28:21.587]                       return(sendCondition)
[17:28:21.587]                     ns <- getNamespace("parallel")
[17:28:21.587]                     if (exists("sendData", mode = "function", 
[17:28:21.587]                       envir = ns)) {
[17:28:21.587]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.587]                         envir = ns)
[17:28:21.587]                       envir <- sys.frame(frame)
[17:28:21.587]                       master <- NULL
[17:28:21.587]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.587]                         !identical(envir, emptyenv())) {
[17:28:21.587]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.587]                           inherits = FALSE)) {
[17:28:21.587]                           master <- get("master", mode = "list", 
[17:28:21.587]                             envir = envir, inherits = FALSE)
[17:28:21.587]                           if (inherits(master, c("SOCKnode", 
[17:28:21.587]                             "SOCK0node"))) {
[17:28:21.587]                             sendCondition <<- function(cond) {
[17:28:21.587]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.587]                                 success = TRUE)
[17:28:21.587]                               parallel_sendData(master, data)
[17:28:21.587]                             }
[17:28:21.587]                             return(sendCondition)
[17:28:21.587]                           }
[17:28:21.587]                         }
[17:28:21.587]                         frame <- frame + 1L
[17:28:21.587]                         envir <- sys.frame(frame)
[17:28:21.587]                       }
[17:28:21.587]                     }
[17:28:21.587]                     sendCondition <<- function(cond) NULL
[17:28:21.587]                   }
[17:28:21.587]                 })
[17:28:21.587]                 withCallingHandlers({
[17:28:21.587]                   {
[17:28:21.587]                     sample(x, size = 1L)
[17:28:21.587]                   }
[17:28:21.587]                 }, immediateCondition = function(cond) {
[17:28:21.587]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.587]                   sendCondition(cond)
[17:28:21.587]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.587]                   {
[17:28:21.587]                     inherits <- base::inherits
[17:28:21.587]                     invokeRestart <- base::invokeRestart
[17:28:21.587]                     is.null <- base::is.null
[17:28:21.587]                     muffled <- FALSE
[17:28:21.587]                     if (inherits(cond, "message")) {
[17:28:21.587]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.587]                       if (muffled) 
[17:28:21.587]                         invokeRestart("muffleMessage")
[17:28:21.587]                     }
[17:28:21.587]                     else if (inherits(cond, "warning")) {
[17:28:21.587]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.587]                       if (muffled) 
[17:28:21.587]                         invokeRestart("muffleWarning")
[17:28:21.587]                     }
[17:28:21.587]                     else if (inherits(cond, "condition")) {
[17:28:21.587]                       if (!is.null(pattern)) {
[17:28:21.587]                         computeRestarts <- base::computeRestarts
[17:28:21.587]                         grepl <- base::grepl
[17:28:21.587]                         restarts <- computeRestarts(cond)
[17:28:21.587]                         for (restart in restarts) {
[17:28:21.587]                           name <- restart$name
[17:28:21.587]                           if (is.null(name)) 
[17:28:21.587]                             next
[17:28:21.587]                           if (!grepl(pattern, name)) 
[17:28:21.587]                             next
[17:28:21.587]                           invokeRestart(restart)
[17:28:21.587]                           muffled <- TRUE
[17:28:21.587]                           break
[17:28:21.587]                         }
[17:28:21.587]                       }
[17:28:21.587]                     }
[17:28:21.587]                     invisible(muffled)
[17:28:21.587]                   }
[17:28:21.587]                   muffleCondition(cond)
[17:28:21.587]                 })
[17:28:21.587]             }))
[17:28:21.587]             future::FutureResult(value = ...future.value$value, 
[17:28:21.587]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.587]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.587]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.587]                     ...future.globalenv.names))
[17:28:21.587]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.587]         }, condition = base::local({
[17:28:21.587]             c <- base::c
[17:28:21.587]             inherits <- base::inherits
[17:28:21.587]             invokeRestart <- base::invokeRestart
[17:28:21.587]             length <- base::length
[17:28:21.587]             list <- base::list
[17:28:21.587]             seq.int <- base::seq.int
[17:28:21.587]             signalCondition <- base::signalCondition
[17:28:21.587]             sys.calls <- base::sys.calls
[17:28:21.587]             `[[` <- base::`[[`
[17:28:21.587]             `+` <- base::`+`
[17:28:21.587]             `<<-` <- base::`<<-`
[17:28:21.587]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.587]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.587]                   3L)]
[17:28:21.587]             }
[17:28:21.587]             function(cond) {
[17:28:21.587]                 is_error <- inherits(cond, "error")
[17:28:21.587]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.587]                   NULL)
[17:28:21.587]                 if (is_error) {
[17:28:21.587]                   sessionInformation <- function() {
[17:28:21.587]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.587]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.587]                       search = base::search(), system = base::Sys.info())
[17:28:21.587]                   }
[17:28:21.587]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.587]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.587]                     cond$call), session = sessionInformation(), 
[17:28:21.587]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.587]                   signalCondition(cond)
[17:28:21.587]                 }
[17:28:21.587]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.587]                 "immediateCondition"))) {
[17:28:21.587]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.587]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.587]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.587]                   if (TRUE && !signal) {
[17:28:21.587]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.587]                     {
[17:28:21.587]                       inherits <- base::inherits
[17:28:21.587]                       invokeRestart <- base::invokeRestart
[17:28:21.587]                       is.null <- base::is.null
[17:28:21.587]                       muffled <- FALSE
[17:28:21.587]                       if (inherits(cond, "message")) {
[17:28:21.587]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.587]                         if (muffled) 
[17:28:21.587]                           invokeRestart("muffleMessage")
[17:28:21.587]                       }
[17:28:21.587]                       else if (inherits(cond, "warning")) {
[17:28:21.587]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.587]                         if (muffled) 
[17:28:21.587]                           invokeRestart("muffleWarning")
[17:28:21.587]                       }
[17:28:21.587]                       else if (inherits(cond, "condition")) {
[17:28:21.587]                         if (!is.null(pattern)) {
[17:28:21.587]                           computeRestarts <- base::computeRestarts
[17:28:21.587]                           grepl <- base::grepl
[17:28:21.587]                           restarts <- computeRestarts(cond)
[17:28:21.587]                           for (restart in restarts) {
[17:28:21.587]                             name <- restart$name
[17:28:21.587]                             if (is.null(name)) 
[17:28:21.587]                               next
[17:28:21.587]                             if (!grepl(pattern, name)) 
[17:28:21.587]                               next
[17:28:21.587]                             invokeRestart(restart)
[17:28:21.587]                             muffled <- TRUE
[17:28:21.587]                             break
[17:28:21.587]                           }
[17:28:21.587]                         }
[17:28:21.587]                       }
[17:28:21.587]                       invisible(muffled)
[17:28:21.587]                     }
[17:28:21.587]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.587]                   }
[17:28:21.587]                 }
[17:28:21.587]                 else {
[17:28:21.587]                   if (TRUE) {
[17:28:21.587]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.587]                     {
[17:28:21.587]                       inherits <- base::inherits
[17:28:21.587]                       invokeRestart <- base::invokeRestart
[17:28:21.587]                       is.null <- base::is.null
[17:28:21.587]                       muffled <- FALSE
[17:28:21.587]                       if (inherits(cond, "message")) {
[17:28:21.587]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.587]                         if (muffled) 
[17:28:21.587]                           invokeRestart("muffleMessage")
[17:28:21.587]                       }
[17:28:21.587]                       else if (inherits(cond, "warning")) {
[17:28:21.587]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.587]                         if (muffled) 
[17:28:21.587]                           invokeRestart("muffleWarning")
[17:28:21.587]                       }
[17:28:21.587]                       else if (inherits(cond, "condition")) {
[17:28:21.587]                         if (!is.null(pattern)) {
[17:28:21.587]                           computeRestarts <- base::computeRestarts
[17:28:21.587]                           grepl <- base::grepl
[17:28:21.587]                           restarts <- computeRestarts(cond)
[17:28:21.587]                           for (restart in restarts) {
[17:28:21.587]                             name <- restart$name
[17:28:21.587]                             if (is.null(name)) 
[17:28:21.587]                               next
[17:28:21.587]                             if (!grepl(pattern, name)) 
[17:28:21.587]                               next
[17:28:21.587]                             invokeRestart(restart)
[17:28:21.587]                             muffled <- TRUE
[17:28:21.587]                             break
[17:28:21.587]                           }
[17:28:21.587]                         }
[17:28:21.587]                       }
[17:28:21.587]                       invisible(muffled)
[17:28:21.587]                     }
[17:28:21.587]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.587]                   }
[17:28:21.587]                 }
[17:28:21.587]             }
[17:28:21.587]         }))
[17:28:21.587]     }, error = function(ex) {
[17:28:21.587]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.587]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.587]                 ...future.rng), started = ...future.startTime, 
[17:28:21.587]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.587]             version = "1.8"), class = "FutureResult")
[17:28:21.587]     }, finally = {
[17:28:21.587]         if (!identical(...future.workdir, getwd())) 
[17:28:21.587]             setwd(...future.workdir)
[17:28:21.587]         {
[17:28:21.587]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.587]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.587]             }
[17:28:21.587]             base::options(...future.oldOptions)
[17:28:21.587]             if (.Platform$OS.type == "windows") {
[17:28:21.587]                 old_names <- names(...future.oldEnvVars)
[17:28:21.587]                 envs <- base::Sys.getenv()
[17:28:21.587]                 names <- names(envs)
[17:28:21.587]                 common <- intersect(names, old_names)
[17:28:21.587]                 added <- setdiff(names, old_names)
[17:28:21.587]                 removed <- setdiff(old_names, names)
[17:28:21.587]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.587]                   envs[common]]
[17:28:21.587]                 NAMES <- toupper(changed)
[17:28:21.587]                 args <- list()
[17:28:21.587]                 for (kk in seq_along(NAMES)) {
[17:28:21.587]                   name <- changed[[kk]]
[17:28:21.587]                   NAME <- NAMES[[kk]]
[17:28:21.587]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.587]                     next
[17:28:21.587]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.587]                 }
[17:28:21.587]                 NAMES <- toupper(added)
[17:28:21.587]                 for (kk in seq_along(NAMES)) {
[17:28:21.587]                   name <- added[[kk]]
[17:28:21.587]                   NAME <- NAMES[[kk]]
[17:28:21.587]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.587]                     next
[17:28:21.587]                   args[[name]] <- ""
[17:28:21.587]                 }
[17:28:21.587]                 NAMES <- toupper(removed)
[17:28:21.587]                 for (kk in seq_along(NAMES)) {
[17:28:21.587]                   name <- removed[[kk]]
[17:28:21.587]                   NAME <- NAMES[[kk]]
[17:28:21.587]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.587]                     next
[17:28:21.587]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.587]                 }
[17:28:21.587]                 if (length(args) > 0) 
[17:28:21.587]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.587]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.587]             }
[17:28:21.587]             else {
[17:28:21.587]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.587]             }
[17:28:21.587]             {
[17:28:21.587]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.587]                   0L) {
[17:28:21.587]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.587]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.587]                   base::options(opts)
[17:28:21.587]                 }
[17:28:21.587]                 {
[17:28:21.587]                   {
[17:28:21.587]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.587]                     NULL
[17:28:21.587]                   }
[17:28:21.587]                   options(future.plan = NULL)
[17:28:21.587]                   if (is.na(NA_character_)) 
[17:28:21.587]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.587]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.587]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.587]                     .init = FALSE)
[17:28:21.587]                 }
[17:28:21.587]             }
[17:28:21.587]         }
[17:28:21.587]     })
[17:28:21.587]     if (TRUE) {
[17:28:21.587]         base::sink(type = "output", split = FALSE)
[17:28:21.587]         if (TRUE) {
[17:28:21.587]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.587]         }
[17:28:21.587]         else {
[17:28:21.587]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.587]         }
[17:28:21.587]         base::close(...future.stdout)
[17:28:21.587]         ...future.stdout <- NULL
[17:28:21.587]     }
[17:28:21.587]     ...future.result$conditions <- ...future.conditions
[17:28:21.587]     ...future.result$finished <- base::Sys.time()
[17:28:21.587]     ...future.result
[17:28:21.587] }
[17:28:21.591] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:21.617] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.617] - Validating connection of MultisessionFuture
[17:28:21.617] - received message: FutureResult
[17:28:21.618] - Received FutureResult
[17:28:21.618] - Erased future from FutureRegistry
[17:28:21.618] result() for ClusterFuture ...
[17:28:21.618] - result already collected: FutureResult
[17:28:21.618] result() for ClusterFuture ... done
[17:28:21.618] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:21.619] result() for ClusterFuture ...
[17:28:21.619] - result already collected: FutureResult
[17:28:21.619] result() for ClusterFuture ... done
[17:28:21.619] result() for ClusterFuture ...
[17:28:21.619] - result already collected: FutureResult
[17:28:21.619] result() for ClusterFuture ... done
[17:28:21.620] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:21.620] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:21.621] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:21.621] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:21.622] MultisessionFuture started
[17:28:21.622] - Launch lazy future ... done
[17:28:21.622] run() for 'MultisessionFuture' ... done
[17:28:21.623] getGlobalsAndPackages() ...
[17:28:21.623] Searching for globals...
[17:28:21.624] - globals found: [3] '{', 'sample', 'x'
[17:28:21.624] Searching for globals ... DONE
[17:28:21.624] Resolving globals: FALSE
[17:28:21.625] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.625] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.625] - globals: [1] 'x'
[17:28:21.626] 
[17:28:21.626] getGlobalsAndPackages() ... DONE
[17:28:21.626] run() for 'Future' ...
[17:28:21.626] - state: 'created'
[17:28:21.626] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.640] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.640] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.640]   - Field: 'node'
[17:28:21.640]   - Field: 'label'
[17:28:21.641]   - Field: 'local'
[17:28:21.641]   - Field: 'owner'
[17:28:21.641]   - Field: 'envir'
[17:28:21.641]   - Field: 'workers'
[17:28:21.641]   - Field: 'packages'
[17:28:21.641]   - Field: 'gc'
[17:28:21.642]   - Field: 'conditions'
[17:28:21.642]   - Field: 'persistent'
[17:28:21.642]   - Field: 'expr'
[17:28:21.642]   - Field: 'uuid'
[17:28:21.642]   - Field: 'seed'
[17:28:21.642]   - Field: 'version'
[17:28:21.643]   - Field: 'result'
[17:28:21.643]   - Field: 'asynchronous'
[17:28:21.643]   - Field: 'calls'
[17:28:21.643]   - Field: 'globals'
[17:28:21.643]   - Field: 'stdout'
[17:28:21.644]   - Field: 'earlySignal'
[17:28:21.644]   - Field: 'lazy'
[17:28:21.644]   - Field: 'state'
[17:28:21.644] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.644] - Launch lazy future ...
[17:28:21.645] Packages needed by the future expression (n = 0): <none>
[17:28:21.645] Packages needed by future strategies (n = 0): <none>
[17:28:21.645] {
[17:28:21.645]     {
[17:28:21.645]         {
[17:28:21.645]             ...future.startTime <- base::Sys.time()
[17:28:21.645]             {
[17:28:21.645]                 {
[17:28:21.645]                   {
[17:28:21.645]                     {
[17:28:21.645]                       base::local({
[17:28:21.645]                         has_future <- base::requireNamespace("future", 
[17:28:21.645]                           quietly = TRUE)
[17:28:21.645]                         if (has_future) {
[17:28:21.645]                           ns <- base::getNamespace("future")
[17:28:21.645]                           version <- ns[[".package"]][["version"]]
[17:28:21.645]                           if (is.null(version)) 
[17:28:21.645]                             version <- utils::packageVersion("future")
[17:28:21.645]                         }
[17:28:21.645]                         else {
[17:28:21.645]                           version <- NULL
[17:28:21.645]                         }
[17:28:21.645]                         if (!has_future || version < "1.8.0") {
[17:28:21.645]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.645]                             "", base::R.version$version.string), 
[17:28:21.645]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:21.645]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:21.645]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.645]                               "release", "version")], collapse = " "), 
[17:28:21.645]                             hostname = base::Sys.info()[["nodename"]])
[17:28:21.645]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.645]                             info)
[17:28:21.645]                           info <- base::paste(info, collapse = "; ")
[17:28:21.645]                           if (!has_future) {
[17:28:21.645]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.645]                               info)
[17:28:21.645]                           }
[17:28:21.645]                           else {
[17:28:21.645]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.645]                               info, version)
[17:28:21.645]                           }
[17:28:21.645]                           base::stop(msg)
[17:28:21.645]                         }
[17:28:21.645]                       })
[17:28:21.645]                     }
[17:28:21.645]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.645]                     base::options(mc.cores = 1L)
[17:28:21.645]                   }
[17:28:21.645]                   ...future.strategy.old <- future::plan("list")
[17:28:21.645]                   options(future.plan = NULL)
[17:28:21.645]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.645]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:21.645]                 }
[17:28:21.645]                 ...future.workdir <- getwd()
[17:28:21.645]             }
[17:28:21.645]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.645]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.645]         }
[17:28:21.645]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.645]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.645]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.645]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.645]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.645]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.645]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.645]             base::names(...future.oldOptions))
[17:28:21.645]     }
[17:28:21.645]     if (FALSE) {
[17:28:21.645]     }
[17:28:21.645]     else {
[17:28:21.645]         if (TRUE) {
[17:28:21.645]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.645]                 open = "w")
[17:28:21.645]         }
[17:28:21.645]         else {
[17:28:21.645]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.645]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.645]         }
[17:28:21.645]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.645]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.645]             base::sink(type = "output", split = FALSE)
[17:28:21.645]             base::close(...future.stdout)
[17:28:21.645]         }, add = TRUE)
[17:28:21.645]     }
[17:28:21.645]     ...future.frame <- base::sys.nframe()
[17:28:21.645]     ...future.conditions <- base::list()
[17:28:21.645]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.645]     if (FALSE) {
[17:28:21.645]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.645]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.645]     }
[17:28:21.645]     ...future.result <- base::tryCatch({
[17:28:21.645]         base::withCallingHandlers({
[17:28:21.645]             ...future.value <- base::withVisible(base::local({
[17:28:21.645]                 ...future.makeSendCondition <- base::local({
[17:28:21.645]                   sendCondition <- NULL
[17:28:21.645]                   function(frame = 1L) {
[17:28:21.645]                     if (is.function(sendCondition)) 
[17:28:21.645]                       return(sendCondition)
[17:28:21.645]                     ns <- getNamespace("parallel")
[17:28:21.645]                     if (exists("sendData", mode = "function", 
[17:28:21.645]                       envir = ns)) {
[17:28:21.645]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.645]                         envir = ns)
[17:28:21.645]                       envir <- sys.frame(frame)
[17:28:21.645]                       master <- NULL
[17:28:21.645]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.645]                         !identical(envir, emptyenv())) {
[17:28:21.645]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.645]                           inherits = FALSE)) {
[17:28:21.645]                           master <- get("master", mode = "list", 
[17:28:21.645]                             envir = envir, inherits = FALSE)
[17:28:21.645]                           if (inherits(master, c("SOCKnode", 
[17:28:21.645]                             "SOCK0node"))) {
[17:28:21.645]                             sendCondition <<- function(cond) {
[17:28:21.645]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.645]                                 success = TRUE)
[17:28:21.645]                               parallel_sendData(master, data)
[17:28:21.645]                             }
[17:28:21.645]                             return(sendCondition)
[17:28:21.645]                           }
[17:28:21.645]                         }
[17:28:21.645]                         frame <- frame + 1L
[17:28:21.645]                         envir <- sys.frame(frame)
[17:28:21.645]                       }
[17:28:21.645]                     }
[17:28:21.645]                     sendCondition <<- function(cond) NULL
[17:28:21.645]                   }
[17:28:21.645]                 })
[17:28:21.645]                 withCallingHandlers({
[17:28:21.645]                   {
[17:28:21.645]                     sample(x, size = 1L)
[17:28:21.645]                   }
[17:28:21.645]                 }, immediateCondition = function(cond) {
[17:28:21.645]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.645]                   sendCondition(cond)
[17:28:21.645]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.645]                   {
[17:28:21.645]                     inherits <- base::inherits
[17:28:21.645]                     invokeRestart <- base::invokeRestart
[17:28:21.645]                     is.null <- base::is.null
[17:28:21.645]                     muffled <- FALSE
[17:28:21.645]                     if (inherits(cond, "message")) {
[17:28:21.645]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.645]                       if (muffled) 
[17:28:21.645]                         invokeRestart("muffleMessage")
[17:28:21.645]                     }
[17:28:21.645]                     else if (inherits(cond, "warning")) {
[17:28:21.645]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.645]                       if (muffled) 
[17:28:21.645]                         invokeRestart("muffleWarning")
[17:28:21.645]                     }
[17:28:21.645]                     else if (inherits(cond, "condition")) {
[17:28:21.645]                       if (!is.null(pattern)) {
[17:28:21.645]                         computeRestarts <- base::computeRestarts
[17:28:21.645]                         grepl <- base::grepl
[17:28:21.645]                         restarts <- computeRestarts(cond)
[17:28:21.645]                         for (restart in restarts) {
[17:28:21.645]                           name <- restart$name
[17:28:21.645]                           if (is.null(name)) 
[17:28:21.645]                             next
[17:28:21.645]                           if (!grepl(pattern, name)) 
[17:28:21.645]                             next
[17:28:21.645]                           invokeRestart(restart)
[17:28:21.645]                           muffled <- TRUE
[17:28:21.645]                           break
[17:28:21.645]                         }
[17:28:21.645]                       }
[17:28:21.645]                     }
[17:28:21.645]                     invisible(muffled)
[17:28:21.645]                   }
[17:28:21.645]                   muffleCondition(cond)
[17:28:21.645]                 })
[17:28:21.645]             }))
[17:28:21.645]             future::FutureResult(value = ...future.value$value, 
[17:28:21.645]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.645]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.645]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.645]                     ...future.globalenv.names))
[17:28:21.645]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.645]         }, condition = base::local({
[17:28:21.645]             c <- base::c
[17:28:21.645]             inherits <- base::inherits
[17:28:21.645]             invokeRestart <- base::invokeRestart
[17:28:21.645]             length <- base::length
[17:28:21.645]             list <- base::list
[17:28:21.645]             seq.int <- base::seq.int
[17:28:21.645]             signalCondition <- base::signalCondition
[17:28:21.645]             sys.calls <- base::sys.calls
[17:28:21.645]             `[[` <- base::`[[`
[17:28:21.645]             `+` <- base::`+`
[17:28:21.645]             `<<-` <- base::`<<-`
[17:28:21.645]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.645]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.645]                   3L)]
[17:28:21.645]             }
[17:28:21.645]             function(cond) {
[17:28:21.645]                 is_error <- inherits(cond, "error")
[17:28:21.645]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.645]                   NULL)
[17:28:21.645]                 if (is_error) {
[17:28:21.645]                   sessionInformation <- function() {
[17:28:21.645]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.645]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.645]                       search = base::search(), system = base::Sys.info())
[17:28:21.645]                   }
[17:28:21.645]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.645]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.645]                     cond$call), session = sessionInformation(), 
[17:28:21.645]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.645]                   signalCondition(cond)
[17:28:21.645]                 }
[17:28:21.645]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.645]                 "immediateCondition"))) {
[17:28:21.645]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.645]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.645]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.645]                   if (TRUE && !signal) {
[17:28:21.645]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.645]                     {
[17:28:21.645]                       inherits <- base::inherits
[17:28:21.645]                       invokeRestart <- base::invokeRestart
[17:28:21.645]                       is.null <- base::is.null
[17:28:21.645]                       muffled <- FALSE
[17:28:21.645]                       if (inherits(cond, "message")) {
[17:28:21.645]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.645]                         if (muffled) 
[17:28:21.645]                           invokeRestart("muffleMessage")
[17:28:21.645]                       }
[17:28:21.645]                       else if (inherits(cond, "warning")) {
[17:28:21.645]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.645]                         if (muffled) 
[17:28:21.645]                           invokeRestart("muffleWarning")
[17:28:21.645]                       }
[17:28:21.645]                       else if (inherits(cond, "condition")) {
[17:28:21.645]                         if (!is.null(pattern)) {
[17:28:21.645]                           computeRestarts <- base::computeRestarts
[17:28:21.645]                           grepl <- base::grepl
[17:28:21.645]                           restarts <- computeRestarts(cond)
[17:28:21.645]                           for (restart in restarts) {
[17:28:21.645]                             name <- restart$name
[17:28:21.645]                             if (is.null(name)) 
[17:28:21.645]                               next
[17:28:21.645]                             if (!grepl(pattern, name)) 
[17:28:21.645]                               next
[17:28:21.645]                             invokeRestart(restart)
[17:28:21.645]                             muffled <- TRUE
[17:28:21.645]                             break
[17:28:21.645]                           }
[17:28:21.645]                         }
[17:28:21.645]                       }
[17:28:21.645]                       invisible(muffled)
[17:28:21.645]                     }
[17:28:21.645]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.645]                   }
[17:28:21.645]                 }
[17:28:21.645]                 else {
[17:28:21.645]                   if (TRUE) {
[17:28:21.645]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.645]                     {
[17:28:21.645]                       inherits <- base::inherits
[17:28:21.645]                       invokeRestart <- base::invokeRestart
[17:28:21.645]                       is.null <- base::is.null
[17:28:21.645]                       muffled <- FALSE
[17:28:21.645]                       if (inherits(cond, "message")) {
[17:28:21.645]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.645]                         if (muffled) 
[17:28:21.645]                           invokeRestart("muffleMessage")
[17:28:21.645]                       }
[17:28:21.645]                       else if (inherits(cond, "warning")) {
[17:28:21.645]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.645]                         if (muffled) 
[17:28:21.645]                           invokeRestart("muffleWarning")
[17:28:21.645]                       }
[17:28:21.645]                       else if (inherits(cond, "condition")) {
[17:28:21.645]                         if (!is.null(pattern)) {
[17:28:21.645]                           computeRestarts <- base::computeRestarts
[17:28:21.645]                           grepl <- base::grepl
[17:28:21.645]                           restarts <- computeRestarts(cond)
[17:28:21.645]                           for (restart in restarts) {
[17:28:21.645]                             name <- restart$name
[17:28:21.645]                             if (is.null(name)) 
[17:28:21.645]                               next
[17:28:21.645]                             if (!grepl(pattern, name)) 
[17:28:21.645]                               next
[17:28:21.645]                             invokeRestart(restart)
[17:28:21.645]                             muffled <- TRUE
[17:28:21.645]                             break
[17:28:21.645]                           }
[17:28:21.645]                         }
[17:28:21.645]                       }
[17:28:21.645]                       invisible(muffled)
[17:28:21.645]                     }
[17:28:21.645]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.645]                   }
[17:28:21.645]                 }
[17:28:21.645]             }
[17:28:21.645]         }))
[17:28:21.645]     }, error = function(ex) {
[17:28:21.645]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.645]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.645]                 ...future.rng), started = ...future.startTime, 
[17:28:21.645]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.645]             version = "1.8"), class = "FutureResult")
[17:28:21.645]     }, finally = {
[17:28:21.645]         if (!identical(...future.workdir, getwd())) 
[17:28:21.645]             setwd(...future.workdir)
[17:28:21.645]         {
[17:28:21.645]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.645]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.645]             }
[17:28:21.645]             base::options(...future.oldOptions)
[17:28:21.645]             if (.Platform$OS.type == "windows") {
[17:28:21.645]                 old_names <- names(...future.oldEnvVars)
[17:28:21.645]                 envs <- base::Sys.getenv()
[17:28:21.645]                 names <- names(envs)
[17:28:21.645]                 common <- intersect(names, old_names)
[17:28:21.645]                 added <- setdiff(names, old_names)
[17:28:21.645]                 removed <- setdiff(old_names, names)
[17:28:21.645]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.645]                   envs[common]]
[17:28:21.645]                 NAMES <- toupper(changed)
[17:28:21.645]                 args <- list()
[17:28:21.645]                 for (kk in seq_along(NAMES)) {
[17:28:21.645]                   name <- changed[[kk]]
[17:28:21.645]                   NAME <- NAMES[[kk]]
[17:28:21.645]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.645]                     next
[17:28:21.645]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.645]                 }
[17:28:21.645]                 NAMES <- toupper(added)
[17:28:21.645]                 for (kk in seq_along(NAMES)) {
[17:28:21.645]                   name <- added[[kk]]
[17:28:21.645]                   NAME <- NAMES[[kk]]
[17:28:21.645]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.645]                     next
[17:28:21.645]                   args[[name]] <- ""
[17:28:21.645]                 }
[17:28:21.645]                 NAMES <- toupper(removed)
[17:28:21.645]                 for (kk in seq_along(NAMES)) {
[17:28:21.645]                   name <- removed[[kk]]
[17:28:21.645]                   NAME <- NAMES[[kk]]
[17:28:21.645]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.645]                     next
[17:28:21.645]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.645]                 }
[17:28:21.645]                 if (length(args) > 0) 
[17:28:21.645]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.645]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.645]             }
[17:28:21.645]             else {
[17:28:21.645]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.645]             }
[17:28:21.645]             {
[17:28:21.645]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.645]                   0L) {
[17:28:21.645]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.645]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.645]                   base::options(opts)
[17:28:21.645]                 }
[17:28:21.645]                 {
[17:28:21.645]                   {
[17:28:21.645]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.645]                     NULL
[17:28:21.645]                   }
[17:28:21.645]                   options(future.plan = NULL)
[17:28:21.645]                   if (is.na(NA_character_)) 
[17:28:21.645]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.645]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.645]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.645]                     .init = FALSE)
[17:28:21.645]                 }
[17:28:21.645]             }
[17:28:21.645]         }
[17:28:21.645]     })
[17:28:21.645]     if (TRUE) {
[17:28:21.645]         base::sink(type = "output", split = FALSE)
[17:28:21.645]         if (TRUE) {
[17:28:21.645]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.645]         }
[17:28:21.645]         else {
[17:28:21.645]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.645]         }
[17:28:21.645]         base::close(...future.stdout)
[17:28:21.645]         ...future.stdout <- NULL
[17:28:21.645]     }
[17:28:21.645]     ...future.result$conditions <- ...future.conditions
[17:28:21.645]     ...future.result$finished <- base::Sys.time()
[17:28:21.645]     ...future.result
[17:28:21.645] }
[17:28:21.650] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:21.664] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.664] - Validating connection of MultisessionFuture
[17:28:21.664] - received message: FutureResult
[17:28:21.664] - Received FutureResult
[17:28:21.665] - Erased future from FutureRegistry
[17:28:21.665] result() for ClusterFuture ...
[17:28:21.665] - result already collected: FutureResult
[17:28:21.665] result() for ClusterFuture ... done
[17:28:21.665] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:21.665] result() for ClusterFuture ...
[17:28:21.666] - result already collected: FutureResult
[17:28:21.666] result() for ClusterFuture ... done
[17:28:21.666] result() for ClusterFuture ...
[17:28:21.666] - result already collected: FutureResult
[17:28:21.666] result() for ClusterFuture ... done
[17:28:21.667] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:21.667] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:21.668] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:21.668] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:21.669] MultisessionFuture started
[17:28:21.669] - Launch lazy future ... done
[17:28:21.669] run() for 'MultisessionFuture' ... done
[17:28:21.669] result() for ClusterFuture ...
[17:28:21.669] - result already collected: FutureResult
[17:28:21.669] result() for ClusterFuture ... done
[17:28:21.670] result() for ClusterFuture ...
[17:28:21.670] - result already collected: FutureResult
[17:28:21.670] result() for ClusterFuture ... done
[17:28:21.670] result() for ClusterFuture ...
[17:28:21.670] - result already collected: FutureResult
[17:28:21.671] result() for ClusterFuture ... done
[17:28:21.671] result() for ClusterFuture ...
[17:28:21.671] - result already collected: FutureResult
[17:28:21.671] result() for ClusterFuture ... done
[17:28:21.671] result() for ClusterFuture ...
[17:28:21.671] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.672] - Validating connection of MultisessionFuture
[17:28:21.672] - received message: FutureResult
[17:28:21.672] - Received FutureResult
[17:28:21.672] - Erased future from FutureRegistry
[17:28:21.672] result() for ClusterFuture ...
[17:28:21.672] - result already collected: FutureResult
[17:28:21.673] result() for ClusterFuture ... done
[17:28:21.673] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:21.673] result() for ClusterFuture ... done
[17:28:21.673] result() for ClusterFuture ...
[17:28:21.673] - result already collected: FutureResult
[17:28:21.673] result() for ClusterFuture ... done
[17:28:21.674] result() for ClusterFuture ...
[17:28:21.674] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.674] - Validating connection of MultisessionFuture
[17:28:21.683] - received message: FutureResult
[17:28:21.684] - Received FutureResult
[17:28:21.684] - Erased future from FutureRegistry
[17:28:21.684] result() for ClusterFuture ...
[17:28:21.684] - result already collected: FutureResult
[17:28:21.684] result() for ClusterFuture ... done
[17:28:21.684] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:21.685] result() for ClusterFuture ... done
[17:28:21.685] result() for ClusterFuture ...
[17:28:21.685] - result already collected: FutureResult
[17:28:21.685] result() for ClusterFuture ... done
[[1]]
[1] 3

[[2]]
[1] 3

[[3]]
[1] 1

[[4]]
[1] 2

[17:28:21.686] getGlobalsAndPackages() ...
[17:28:21.686] Searching for globals...
[17:28:21.687] - globals found: [3] '{', 'sample', 'x'
[17:28:21.687] Searching for globals ... DONE
[17:28:21.688] Resolving globals: FALSE
[17:28:21.688] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.688] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.689] - globals: [1] 'x'
[17:28:21.689] 
[17:28:21.689] getGlobalsAndPackages() ... DONE
[17:28:21.689] run() for 'Future' ...
[17:28:21.690] - state: 'created'
[17:28:21.690] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.703] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.703] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.704]   - Field: 'node'
[17:28:21.704]   - Field: 'label'
[17:28:21.704]   - Field: 'local'
[17:28:21.704]   - Field: 'owner'
[17:28:21.704]   - Field: 'envir'
[17:28:21.704]   - Field: 'workers'
[17:28:21.705]   - Field: 'packages'
[17:28:21.705]   - Field: 'gc'
[17:28:21.705]   - Field: 'conditions'
[17:28:21.705]   - Field: 'persistent'
[17:28:21.705]   - Field: 'expr'
[17:28:21.706]   - Field: 'uuid'
[17:28:21.706]   - Field: 'seed'
[17:28:21.706]   - Field: 'version'
[17:28:21.706]   - Field: 'result'
[17:28:21.706]   - Field: 'asynchronous'
[17:28:21.706]   - Field: 'calls'
[17:28:21.707]   - Field: 'globals'
[17:28:21.707]   - Field: 'stdout'
[17:28:21.707]   - Field: 'earlySignal'
[17:28:21.707]   - Field: 'lazy'
[17:28:21.707]   - Field: 'state'
[17:28:21.707] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.708] - Launch lazy future ...
[17:28:21.708] Packages needed by the future expression (n = 0): <none>
[17:28:21.708] Packages needed by future strategies (n = 0): <none>
[17:28:21.709] {
[17:28:21.709]     {
[17:28:21.709]         {
[17:28:21.709]             ...future.startTime <- base::Sys.time()
[17:28:21.709]             {
[17:28:21.709]                 {
[17:28:21.709]                   {
[17:28:21.709]                     {
[17:28:21.709]                       base::local({
[17:28:21.709]                         has_future <- base::requireNamespace("future", 
[17:28:21.709]                           quietly = TRUE)
[17:28:21.709]                         if (has_future) {
[17:28:21.709]                           ns <- base::getNamespace("future")
[17:28:21.709]                           version <- ns[[".package"]][["version"]]
[17:28:21.709]                           if (is.null(version)) 
[17:28:21.709]                             version <- utils::packageVersion("future")
[17:28:21.709]                         }
[17:28:21.709]                         else {
[17:28:21.709]                           version <- NULL
[17:28:21.709]                         }
[17:28:21.709]                         if (!has_future || version < "1.8.0") {
[17:28:21.709]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.709]                             "", base::R.version$version.string), 
[17:28:21.709]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:21.709]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:21.709]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.709]                               "release", "version")], collapse = " "), 
[17:28:21.709]                             hostname = base::Sys.info()[["nodename"]])
[17:28:21.709]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.709]                             info)
[17:28:21.709]                           info <- base::paste(info, collapse = "; ")
[17:28:21.709]                           if (!has_future) {
[17:28:21.709]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.709]                               info)
[17:28:21.709]                           }
[17:28:21.709]                           else {
[17:28:21.709]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.709]                               info, version)
[17:28:21.709]                           }
[17:28:21.709]                           base::stop(msg)
[17:28:21.709]                         }
[17:28:21.709]                       })
[17:28:21.709]                     }
[17:28:21.709]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.709]                     base::options(mc.cores = 1L)
[17:28:21.709]                   }
[17:28:21.709]                   ...future.strategy.old <- future::plan("list")
[17:28:21.709]                   options(future.plan = NULL)
[17:28:21.709]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.709]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:21.709]                 }
[17:28:21.709]                 ...future.workdir <- getwd()
[17:28:21.709]             }
[17:28:21.709]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.709]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.709]         }
[17:28:21.709]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.709]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.709]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.709]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.709]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.709]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.709]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.709]             base::names(...future.oldOptions))
[17:28:21.709]     }
[17:28:21.709]     if (FALSE) {
[17:28:21.709]     }
[17:28:21.709]     else {
[17:28:21.709]         if (TRUE) {
[17:28:21.709]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.709]                 open = "w")
[17:28:21.709]         }
[17:28:21.709]         else {
[17:28:21.709]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.709]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.709]         }
[17:28:21.709]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.709]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.709]             base::sink(type = "output", split = FALSE)
[17:28:21.709]             base::close(...future.stdout)
[17:28:21.709]         }, add = TRUE)
[17:28:21.709]     }
[17:28:21.709]     ...future.frame <- base::sys.nframe()
[17:28:21.709]     ...future.conditions <- base::list()
[17:28:21.709]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.709]     if (FALSE) {
[17:28:21.709]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.709]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.709]     }
[17:28:21.709]     ...future.result <- base::tryCatch({
[17:28:21.709]         base::withCallingHandlers({
[17:28:21.709]             ...future.value <- base::withVisible(base::local({
[17:28:21.709]                 ...future.makeSendCondition <- base::local({
[17:28:21.709]                   sendCondition <- NULL
[17:28:21.709]                   function(frame = 1L) {
[17:28:21.709]                     if (is.function(sendCondition)) 
[17:28:21.709]                       return(sendCondition)
[17:28:21.709]                     ns <- getNamespace("parallel")
[17:28:21.709]                     if (exists("sendData", mode = "function", 
[17:28:21.709]                       envir = ns)) {
[17:28:21.709]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.709]                         envir = ns)
[17:28:21.709]                       envir <- sys.frame(frame)
[17:28:21.709]                       master <- NULL
[17:28:21.709]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.709]                         !identical(envir, emptyenv())) {
[17:28:21.709]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.709]                           inherits = FALSE)) {
[17:28:21.709]                           master <- get("master", mode = "list", 
[17:28:21.709]                             envir = envir, inherits = FALSE)
[17:28:21.709]                           if (inherits(master, c("SOCKnode", 
[17:28:21.709]                             "SOCK0node"))) {
[17:28:21.709]                             sendCondition <<- function(cond) {
[17:28:21.709]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.709]                                 success = TRUE)
[17:28:21.709]                               parallel_sendData(master, data)
[17:28:21.709]                             }
[17:28:21.709]                             return(sendCondition)
[17:28:21.709]                           }
[17:28:21.709]                         }
[17:28:21.709]                         frame <- frame + 1L
[17:28:21.709]                         envir <- sys.frame(frame)
[17:28:21.709]                       }
[17:28:21.709]                     }
[17:28:21.709]                     sendCondition <<- function(cond) NULL
[17:28:21.709]                   }
[17:28:21.709]                 })
[17:28:21.709]                 withCallingHandlers({
[17:28:21.709]                   {
[17:28:21.709]                     sample(x, size = 1L)
[17:28:21.709]                   }
[17:28:21.709]                 }, immediateCondition = function(cond) {
[17:28:21.709]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.709]                   sendCondition(cond)
[17:28:21.709]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.709]                   {
[17:28:21.709]                     inherits <- base::inherits
[17:28:21.709]                     invokeRestart <- base::invokeRestart
[17:28:21.709]                     is.null <- base::is.null
[17:28:21.709]                     muffled <- FALSE
[17:28:21.709]                     if (inherits(cond, "message")) {
[17:28:21.709]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.709]                       if (muffled) 
[17:28:21.709]                         invokeRestart("muffleMessage")
[17:28:21.709]                     }
[17:28:21.709]                     else if (inherits(cond, "warning")) {
[17:28:21.709]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.709]                       if (muffled) 
[17:28:21.709]                         invokeRestart("muffleWarning")
[17:28:21.709]                     }
[17:28:21.709]                     else if (inherits(cond, "condition")) {
[17:28:21.709]                       if (!is.null(pattern)) {
[17:28:21.709]                         computeRestarts <- base::computeRestarts
[17:28:21.709]                         grepl <- base::grepl
[17:28:21.709]                         restarts <- computeRestarts(cond)
[17:28:21.709]                         for (restart in restarts) {
[17:28:21.709]                           name <- restart$name
[17:28:21.709]                           if (is.null(name)) 
[17:28:21.709]                             next
[17:28:21.709]                           if (!grepl(pattern, name)) 
[17:28:21.709]                             next
[17:28:21.709]                           invokeRestart(restart)
[17:28:21.709]                           muffled <- TRUE
[17:28:21.709]                           break
[17:28:21.709]                         }
[17:28:21.709]                       }
[17:28:21.709]                     }
[17:28:21.709]                     invisible(muffled)
[17:28:21.709]                   }
[17:28:21.709]                   muffleCondition(cond)
[17:28:21.709]                 })
[17:28:21.709]             }))
[17:28:21.709]             future::FutureResult(value = ...future.value$value, 
[17:28:21.709]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.709]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.709]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.709]                     ...future.globalenv.names))
[17:28:21.709]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.709]         }, condition = base::local({
[17:28:21.709]             c <- base::c
[17:28:21.709]             inherits <- base::inherits
[17:28:21.709]             invokeRestart <- base::invokeRestart
[17:28:21.709]             length <- base::length
[17:28:21.709]             list <- base::list
[17:28:21.709]             seq.int <- base::seq.int
[17:28:21.709]             signalCondition <- base::signalCondition
[17:28:21.709]             sys.calls <- base::sys.calls
[17:28:21.709]             `[[` <- base::`[[`
[17:28:21.709]             `+` <- base::`+`
[17:28:21.709]             `<<-` <- base::`<<-`
[17:28:21.709]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.709]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.709]                   3L)]
[17:28:21.709]             }
[17:28:21.709]             function(cond) {
[17:28:21.709]                 is_error <- inherits(cond, "error")
[17:28:21.709]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.709]                   NULL)
[17:28:21.709]                 if (is_error) {
[17:28:21.709]                   sessionInformation <- function() {
[17:28:21.709]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.709]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.709]                       search = base::search(), system = base::Sys.info())
[17:28:21.709]                   }
[17:28:21.709]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.709]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.709]                     cond$call), session = sessionInformation(), 
[17:28:21.709]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.709]                   signalCondition(cond)
[17:28:21.709]                 }
[17:28:21.709]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.709]                 "immediateCondition"))) {
[17:28:21.709]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.709]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.709]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.709]                   if (TRUE && !signal) {
[17:28:21.709]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.709]                     {
[17:28:21.709]                       inherits <- base::inherits
[17:28:21.709]                       invokeRestart <- base::invokeRestart
[17:28:21.709]                       is.null <- base::is.null
[17:28:21.709]                       muffled <- FALSE
[17:28:21.709]                       if (inherits(cond, "message")) {
[17:28:21.709]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.709]                         if (muffled) 
[17:28:21.709]                           invokeRestart("muffleMessage")
[17:28:21.709]                       }
[17:28:21.709]                       else if (inherits(cond, "warning")) {
[17:28:21.709]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.709]                         if (muffled) 
[17:28:21.709]                           invokeRestart("muffleWarning")
[17:28:21.709]                       }
[17:28:21.709]                       else if (inherits(cond, "condition")) {
[17:28:21.709]                         if (!is.null(pattern)) {
[17:28:21.709]                           computeRestarts <- base::computeRestarts
[17:28:21.709]                           grepl <- base::grepl
[17:28:21.709]                           restarts <- computeRestarts(cond)
[17:28:21.709]                           for (restart in restarts) {
[17:28:21.709]                             name <- restart$name
[17:28:21.709]                             if (is.null(name)) 
[17:28:21.709]                               next
[17:28:21.709]                             if (!grepl(pattern, name)) 
[17:28:21.709]                               next
[17:28:21.709]                             invokeRestart(restart)
[17:28:21.709]                             muffled <- TRUE
[17:28:21.709]                             break
[17:28:21.709]                           }
[17:28:21.709]                         }
[17:28:21.709]                       }
[17:28:21.709]                       invisible(muffled)
[17:28:21.709]                     }
[17:28:21.709]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.709]                   }
[17:28:21.709]                 }
[17:28:21.709]                 else {
[17:28:21.709]                   if (TRUE) {
[17:28:21.709]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.709]                     {
[17:28:21.709]                       inherits <- base::inherits
[17:28:21.709]                       invokeRestart <- base::invokeRestart
[17:28:21.709]                       is.null <- base::is.null
[17:28:21.709]                       muffled <- FALSE
[17:28:21.709]                       if (inherits(cond, "message")) {
[17:28:21.709]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.709]                         if (muffled) 
[17:28:21.709]                           invokeRestart("muffleMessage")
[17:28:21.709]                       }
[17:28:21.709]                       else if (inherits(cond, "warning")) {
[17:28:21.709]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.709]                         if (muffled) 
[17:28:21.709]                           invokeRestart("muffleWarning")
[17:28:21.709]                       }
[17:28:21.709]                       else if (inherits(cond, "condition")) {
[17:28:21.709]                         if (!is.null(pattern)) {
[17:28:21.709]                           computeRestarts <- base::computeRestarts
[17:28:21.709]                           grepl <- base::grepl
[17:28:21.709]                           restarts <- computeRestarts(cond)
[17:28:21.709]                           for (restart in restarts) {
[17:28:21.709]                             name <- restart$name
[17:28:21.709]                             if (is.null(name)) 
[17:28:21.709]                               next
[17:28:21.709]                             if (!grepl(pattern, name)) 
[17:28:21.709]                               next
[17:28:21.709]                             invokeRestart(restart)
[17:28:21.709]                             muffled <- TRUE
[17:28:21.709]                             break
[17:28:21.709]                           }
[17:28:21.709]                         }
[17:28:21.709]                       }
[17:28:21.709]                       invisible(muffled)
[17:28:21.709]                     }
[17:28:21.709]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.709]                   }
[17:28:21.709]                 }
[17:28:21.709]             }
[17:28:21.709]         }))
[17:28:21.709]     }, error = function(ex) {
[17:28:21.709]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.709]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.709]                 ...future.rng), started = ...future.startTime, 
[17:28:21.709]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.709]             version = "1.8"), class = "FutureResult")
[17:28:21.709]     }, finally = {
[17:28:21.709]         if (!identical(...future.workdir, getwd())) 
[17:28:21.709]             setwd(...future.workdir)
[17:28:21.709]         {
[17:28:21.709]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.709]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.709]             }
[17:28:21.709]             base::options(...future.oldOptions)
[17:28:21.709]             if (.Platform$OS.type == "windows") {
[17:28:21.709]                 old_names <- names(...future.oldEnvVars)
[17:28:21.709]                 envs <- base::Sys.getenv()
[17:28:21.709]                 names <- names(envs)
[17:28:21.709]                 common <- intersect(names, old_names)
[17:28:21.709]                 added <- setdiff(names, old_names)
[17:28:21.709]                 removed <- setdiff(old_names, names)
[17:28:21.709]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.709]                   envs[common]]
[17:28:21.709]                 NAMES <- toupper(changed)
[17:28:21.709]                 args <- list()
[17:28:21.709]                 for (kk in seq_along(NAMES)) {
[17:28:21.709]                   name <- changed[[kk]]
[17:28:21.709]                   NAME <- NAMES[[kk]]
[17:28:21.709]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.709]                     next
[17:28:21.709]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.709]                 }
[17:28:21.709]                 NAMES <- toupper(added)
[17:28:21.709]                 for (kk in seq_along(NAMES)) {
[17:28:21.709]                   name <- added[[kk]]
[17:28:21.709]                   NAME <- NAMES[[kk]]
[17:28:21.709]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.709]                     next
[17:28:21.709]                   args[[name]] <- ""
[17:28:21.709]                 }
[17:28:21.709]                 NAMES <- toupper(removed)
[17:28:21.709]                 for (kk in seq_along(NAMES)) {
[17:28:21.709]                   name <- removed[[kk]]
[17:28:21.709]                   NAME <- NAMES[[kk]]
[17:28:21.709]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.709]                     next
[17:28:21.709]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.709]                 }
[17:28:21.709]                 if (length(args) > 0) 
[17:28:21.709]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.709]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.709]             }
[17:28:21.709]             else {
[17:28:21.709]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.709]             }
[17:28:21.709]             {
[17:28:21.709]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.709]                   0L) {
[17:28:21.709]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.709]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.709]                   base::options(opts)
[17:28:21.709]                 }
[17:28:21.709]                 {
[17:28:21.709]                   {
[17:28:21.709]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.709]                     NULL
[17:28:21.709]                   }
[17:28:21.709]                   options(future.plan = NULL)
[17:28:21.709]                   if (is.na(NA_character_)) 
[17:28:21.709]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.709]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.709]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.709]                     .init = FALSE)
[17:28:21.709]                 }
[17:28:21.709]             }
[17:28:21.709]         }
[17:28:21.709]     })
[17:28:21.709]     if (TRUE) {
[17:28:21.709]         base::sink(type = "output", split = FALSE)
[17:28:21.709]         if (TRUE) {
[17:28:21.709]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.709]         }
[17:28:21.709]         else {
[17:28:21.709]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.709]         }
[17:28:21.709]         base::close(...future.stdout)
[17:28:21.709]         ...future.stdout <- NULL
[17:28:21.709]     }
[17:28:21.709]     ...future.result$conditions <- ...future.conditions
[17:28:21.709]     ...future.result$finished <- base::Sys.time()
[17:28:21.709]     ...future.result
[17:28:21.709] }
[17:28:21.714] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:21.714] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:21.714] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:21.715] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:21.715] MultisessionFuture started
[17:28:21.715] - Launch lazy future ... done
[17:28:21.716] run() for 'MultisessionFuture' ... done
[17:28:21.716] getGlobalsAndPackages() ...
[17:28:21.716] Searching for globals...
[17:28:21.718] - globals found: [3] '{', 'sample', 'x'
[17:28:21.718] Searching for globals ... DONE
[17:28:21.718] Resolving globals: FALSE
[17:28:21.718] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.719] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.719] - globals: [1] 'x'
[17:28:21.719] 
[17:28:21.719] getGlobalsAndPackages() ... DONE
[17:28:21.720] run() for 'Future' ...
[17:28:21.720] - state: 'created'
[17:28:21.720] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.733] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.734] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.734]   - Field: 'node'
[17:28:21.734]   - Field: 'label'
[17:28:21.734]   - Field: 'local'
[17:28:21.734]   - Field: 'owner'
[17:28:21.735]   - Field: 'envir'
[17:28:21.735]   - Field: 'workers'
[17:28:21.735]   - Field: 'packages'
[17:28:21.735]   - Field: 'gc'
[17:28:21.735]   - Field: 'conditions'
[17:28:21.735]   - Field: 'persistent'
[17:28:21.736]   - Field: 'expr'
[17:28:21.736]   - Field: 'uuid'
[17:28:21.736]   - Field: 'seed'
[17:28:21.736]   - Field: 'version'
[17:28:21.736]   - Field: 'result'
[17:28:21.736]   - Field: 'asynchronous'
[17:28:21.737]   - Field: 'calls'
[17:28:21.737]   - Field: 'globals'
[17:28:21.737]   - Field: 'stdout'
[17:28:21.737]   - Field: 'earlySignal'
[17:28:21.737]   - Field: 'lazy'
[17:28:21.738]   - Field: 'state'
[17:28:21.738] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.738] - Launch lazy future ...
[17:28:21.738] Packages needed by the future expression (n = 0): <none>
[17:28:21.738] Packages needed by future strategies (n = 0): <none>
[17:28:21.739] {
[17:28:21.739]     {
[17:28:21.739]         {
[17:28:21.739]             ...future.startTime <- base::Sys.time()
[17:28:21.739]             {
[17:28:21.739]                 {
[17:28:21.739]                   {
[17:28:21.739]                     {
[17:28:21.739]                       base::local({
[17:28:21.739]                         has_future <- base::requireNamespace("future", 
[17:28:21.739]                           quietly = TRUE)
[17:28:21.739]                         if (has_future) {
[17:28:21.739]                           ns <- base::getNamespace("future")
[17:28:21.739]                           version <- ns[[".package"]][["version"]]
[17:28:21.739]                           if (is.null(version)) 
[17:28:21.739]                             version <- utils::packageVersion("future")
[17:28:21.739]                         }
[17:28:21.739]                         else {
[17:28:21.739]                           version <- NULL
[17:28:21.739]                         }
[17:28:21.739]                         if (!has_future || version < "1.8.0") {
[17:28:21.739]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.739]                             "", base::R.version$version.string), 
[17:28:21.739]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:21.739]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:21.739]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.739]                               "release", "version")], collapse = " "), 
[17:28:21.739]                             hostname = base::Sys.info()[["nodename"]])
[17:28:21.739]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.739]                             info)
[17:28:21.739]                           info <- base::paste(info, collapse = "; ")
[17:28:21.739]                           if (!has_future) {
[17:28:21.739]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.739]                               info)
[17:28:21.739]                           }
[17:28:21.739]                           else {
[17:28:21.739]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.739]                               info, version)
[17:28:21.739]                           }
[17:28:21.739]                           base::stop(msg)
[17:28:21.739]                         }
[17:28:21.739]                       })
[17:28:21.739]                     }
[17:28:21.739]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.739]                     base::options(mc.cores = 1L)
[17:28:21.739]                   }
[17:28:21.739]                   ...future.strategy.old <- future::plan("list")
[17:28:21.739]                   options(future.plan = NULL)
[17:28:21.739]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.739]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:21.739]                 }
[17:28:21.739]                 ...future.workdir <- getwd()
[17:28:21.739]             }
[17:28:21.739]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.739]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.739]         }
[17:28:21.739]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.739]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.739]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.739]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.739]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.739]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.739]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.739]             base::names(...future.oldOptions))
[17:28:21.739]     }
[17:28:21.739]     if (FALSE) {
[17:28:21.739]     }
[17:28:21.739]     else {
[17:28:21.739]         if (TRUE) {
[17:28:21.739]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.739]                 open = "w")
[17:28:21.739]         }
[17:28:21.739]         else {
[17:28:21.739]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.739]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.739]         }
[17:28:21.739]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.739]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.739]             base::sink(type = "output", split = FALSE)
[17:28:21.739]             base::close(...future.stdout)
[17:28:21.739]         }, add = TRUE)
[17:28:21.739]     }
[17:28:21.739]     ...future.frame <- base::sys.nframe()
[17:28:21.739]     ...future.conditions <- base::list()
[17:28:21.739]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.739]     if (FALSE) {
[17:28:21.739]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.739]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.739]     }
[17:28:21.739]     ...future.result <- base::tryCatch({
[17:28:21.739]         base::withCallingHandlers({
[17:28:21.739]             ...future.value <- base::withVisible(base::local({
[17:28:21.739]                 ...future.makeSendCondition <- base::local({
[17:28:21.739]                   sendCondition <- NULL
[17:28:21.739]                   function(frame = 1L) {
[17:28:21.739]                     if (is.function(sendCondition)) 
[17:28:21.739]                       return(sendCondition)
[17:28:21.739]                     ns <- getNamespace("parallel")
[17:28:21.739]                     if (exists("sendData", mode = "function", 
[17:28:21.739]                       envir = ns)) {
[17:28:21.739]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.739]                         envir = ns)
[17:28:21.739]                       envir <- sys.frame(frame)
[17:28:21.739]                       master <- NULL
[17:28:21.739]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.739]                         !identical(envir, emptyenv())) {
[17:28:21.739]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.739]                           inherits = FALSE)) {
[17:28:21.739]                           master <- get("master", mode = "list", 
[17:28:21.739]                             envir = envir, inherits = FALSE)
[17:28:21.739]                           if (inherits(master, c("SOCKnode", 
[17:28:21.739]                             "SOCK0node"))) {
[17:28:21.739]                             sendCondition <<- function(cond) {
[17:28:21.739]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.739]                                 success = TRUE)
[17:28:21.739]                               parallel_sendData(master, data)
[17:28:21.739]                             }
[17:28:21.739]                             return(sendCondition)
[17:28:21.739]                           }
[17:28:21.739]                         }
[17:28:21.739]                         frame <- frame + 1L
[17:28:21.739]                         envir <- sys.frame(frame)
[17:28:21.739]                       }
[17:28:21.739]                     }
[17:28:21.739]                     sendCondition <<- function(cond) NULL
[17:28:21.739]                   }
[17:28:21.739]                 })
[17:28:21.739]                 withCallingHandlers({
[17:28:21.739]                   {
[17:28:21.739]                     sample(x, size = 1L)
[17:28:21.739]                   }
[17:28:21.739]                 }, immediateCondition = function(cond) {
[17:28:21.739]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.739]                   sendCondition(cond)
[17:28:21.739]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.739]                   {
[17:28:21.739]                     inherits <- base::inherits
[17:28:21.739]                     invokeRestart <- base::invokeRestart
[17:28:21.739]                     is.null <- base::is.null
[17:28:21.739]                     muffled <- FALSE
[17:28:21.739]                     if (inherits(cond, "message")) {
[17:28:21.739]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.739]                       if (muffled) 
[17:28:21.739]                         invokeRestart("muffleMessage")
[17:28:21.739]                     }
[17:28:21.739]                     else if (inherits(cond, "warning")) {
[17:28:21.739]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.739]                       if (muffled) 
[17:28:21.739]                         invokeRestart("muffleWarning")
[17:28:21.739]                     }
[17:28:21.739]                     else if (inherits(cond, "condition")) {
[17:28:21.739]                       if (!is.null(pattern)) {
[17:28:21.739]                         computeRestarts <- base::computeRestarts
[17:28:21.739]                         grepl <- base::grepl
[17:28:21.739]                         restarts <- computeRestarts(cond)
[17:28:21.739]                         for (restart in restarts) {
[17:28:21.739]                           name <- restart$name
[17:28:21.739]                           if (is.null(name)) 
[17:28:21.739]                             next
[17:28:21.739]                           if (!grepl(pattern, name)) 
[17:28:21.739]                             next
[17:28:21.739]                           invokeRestart(restart)
[17:28:21.739]                           muffled <- TRUE
[17:28:21.739]                           break
[17:28:21.739]                         }
[17:28:21.739]                       }
[17:28:21.739]                     }
[17:28:21.739]                     invisible(muffled)
[17:28:21.739]                   }
[17:28:21.739]                   muffleCondition(cond)
[17:28:21.739]                 })
[17:28:21.739]             }))
[17:28:21.739]             future::FutureResult(value = ...future.value$value, 
[17:28:21.739]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.739]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.739]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.739]                     ...future.globalenv.names))
[17:28:21.739]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.739]         }, condition = base::local({
[17:28:21.739]             c <- base::c
[17:28:21.739]             inherits <- base::inherits
[17:28:21.739]             invokeRestart <- base::invokeRestart
[17:28:21.739]             length <- base::length
[17:28:21.739]             list <- base::list
[17:28:21.739]             seq.int <- base::seq.int
[17:28:21.739]             signalCondition <- base::signalCondition
[17:28:21.739]             sys.calls <- base::sys.calls
[17:28:21.739]             `[[` <- base::`[[`
[17:28:21.739]             `+` <- base::`+`
[17:28:21.739]             `<<-` <- base::`<<-`
[17:28:21.739]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.739]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.739]                   3L)]
[17:28:21.739]             }
[17:28:21.739]             function(cond) {
[17:28:21.739]                 is_error <- inherits(cond, "error")
[17:28:21.739]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.739]                   NULL)
[17:28:21.739]                 if (is_error) {
[17:28:21.739]                   sessionInformation <- function() {
[17:28:21.739]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.739]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.739]                       search = base::search(), system = base::Sys.info())
[17:28:21.739]                   }
[17:28:21.739]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.739]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.739]                     cond$call), session = sessionInformation(), 
[17:28:21.739]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.739]                   signalCondition(cond)
[17:28:21.739]                 }
[17:28:21.739]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.739]                 "immediateCondition"))) {
[17:28:21.739]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.739]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.739]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.739]                   if (TRUE && !signal) {
[17:28:21.739]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.739]                     {
[17:28:21.739]                       inherits <- base::inherits
[17:28:21.739]                       invokeRestart <- base::invokeRestart
[17:28:21.739]                       is.null <- base::is.null
[17:28:21.739]                       muffled <- FALSE
[17:28:21.739]                       if (inherits(cond, "message")) {
[17:28:21.739]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.739]                         if (muffled) 
[17:28:21.739]                           invokeRestart("muffleMessage")
[17:28:21.739]                       }
[17:28:21.739]                       else if (inherits(cond, "warning")) {
[17:28:21.739]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.739]                         if (muffled) 
[17:28:21.739]                           invokeRestart("muffleWarning")
[17:28:21.739]                       }
[17:28:21.739]                       else if (inherits(cond, "condition")) {
[17:28:21.739]                         if (!is.null(pattern)) {
[17:28:21.739]                           computeRestarts <- base::computeRestarts
[17:28:21.739]                           grepl <- base::grepl
[17:28:21.739]                           restarts <- computeRestarts(cond)
[17:28:21.739]                           for (restart in restarts) {
[17:28:21.739]                             name <- restart$name
[17:28:21.739]                             if (is.null(name)) 
[17:28:21.739]                               next
[17:28:21.739]                             if (!grepl(pattern, name)) 
[17:28:21.739]                               next
[17:28:21.739]                             invokeRestart(restart)
[17:28:21.739]                             muffled <- TRUE
[17:28:21.739]                             break
[17:28:21.739]                           }
[17:28:21.739]                         }
[17:28:21.739]                       }
[17:28:21.739]                       invisible(muffled)
[17:28:21.739]                     }
[17:28:21.739]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.739]                   }
[17:28:21.739]                 }
[17:28:21.739]                 else {
[17:28:21.739]                   if (TRUE) {
[17:28:21.739]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.739]                     {
[17:28:21.739]                       inherits <- base::inherits
[17:28:21.739]                       invokeRestart <- base::invokeRestart
[17:28:21.739]                       is.null <- base::is.null
[17:28:21.739]                       muffled <- FALSE
[17:28:21.739]                       if (inherits(cond, "message")) {
[17:28:21.739]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.739]                         if (muffled) 
[17:28:21.739]                           invokeRestart("muffleMessage")
[17:28:21.739]                       }
[17:28:21.739]                       else if (inherits(cond, "warning")) {
[17:28:21.739]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.739]                         if (muffled) 
[17:28:21.739]                           invokeRestart("muffleWarning")
[17:28:21.739]                       }
[17:28:21.739]                       else if (inherits(cond, "condition")) {
[17:28:21.739]                         if (!is.null(pattern)) {
[17:28:21.739]                           computeRestarts <- base::computeRestarts
[17:28:21.739]                           grepl <- base::grepl
[17:28:21.739]                           restarts <- computeRestarts(cond)
[17:28:21.739]                           for (restart in restarts) {
[17:28:21.739]                             name <- restart$name
[17:28:21.739]                             if (is.null(name)) 
[17:28:21.739]                               next
[17:28:21.739]                             if (!grepl(pattern, name)) 
[17:28:21.739]                               next
[17:28:21.739]                             invokeRestart(restart)
[17:28:21.739]                             muffled <- TRUE
[17:28:21.739]                             break
[17:28:21.739]                           }
[17:28:21.739]                         }
[17:28:21.739]                       }
[17:28:21.739]                       invisible(muffled)
[17:28:21.739]                     }
[17:28:21.739]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.739]                   }
[17:28:21.739]                 }
[17:28:21.739]             }
[17:28:21.739]         }))
[17:28:21.739]     }, error = function(ex) {
[17:28:21.739]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.739]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.739]                 ...future.rng), started = ...future.startTime, 
[17:28:21.739]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.739]             version = "1.8"), class = "FutureResult")
[17:28:21.739]     }, finally = {
[17:28:21.739]         if (!identical(...future.workdir, getwd())) 
[17:28:21.739]             setwd(...future.workdir)
[17:28:21.739]         {
[17:28:21.739]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.739]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.739]             }
[17:28:21.739]             base::options(...future.oldOptions)
[17:28:21.739]             if (.Platform$OS.type == "windows") {
[17:28:21.739]                 old_names <- names(...future.oldEnvVars)
[17:28:21.739]                 envs <- base::Sys.getenv()
[17:28:21.739]                 names <- names(envs)
[17:28:21.739]                 common <- intersect(names, old_names)
[17:28:21.739]                 added <- setdiff(names, old_names)
[17:28:21.739]                 removed <- setdiff(old_names, names)
[17:28:21.739]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.739]                   envs[common]]
[17:28:21.739]                 NAMES <- toupper(changed)
[17:28:21.739]                 args <- list()
[17:28:21.739]                 for (kk in seq_along(NAMES)) {
[17:28:21.739]                   name <- changed[[kk]]
[17:28:21.739]                   NAME <- NAMES[[kk]]
[17:28:21.739]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.739]                     next
[17:28:21.739]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.739]                 }
[17:28:21.739]                 NAMES <- toupper(added)
[17:28:21.739]                 for (kk in seq_along(NAMES)) {
[17:28:21.739]                   name <- added[[kk]]
[17:28:21.739]                   NAME <- NAMES[[kk]]
[17:28:21.739]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.739]                     next
[17:28:21.739]                   args[[name]] <- ""
[17:28:21.739]                 }
[17:28:21.739]                 NAMES <- toupper(removed)
[17:28:21.739]                 for (kk in seq_along(NAMES)) {
[17:28:21.739]                   name <- removed[[kk]]
[17:28:21.739]                   NAME <- NAMES[[kk]]
[17:28:21.739]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.739]                     next
[17:28:21.739]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.739]                 }
[17:28:21.739]                 if (length(args) > 0) 
[17:28:21.739]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.739]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.739]             }
[17:28:21.739]             else {
[17:28:21.739]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.739]             }
[17:28:21.739]             {
[17:28:21.739]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.739]                   0L) {
[17:28:21.739]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.739]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.739]                   base::options(opts)
[17:28:21.739]                 }
[17:28:21.739]                 {
[17:28:21.739]                   {
[17:28:21.739]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.739]                     NULL
[17:28:21.739]                   }
[17:28:21.739]                   options(future.plan = NULL)
[17:28:21.739]                   if (is.na(NA_character_)) 
[17:28:21.739]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.739]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.739]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.739]                     .init = FALSE)
[17:28:21.739]                 }
[17:28:21.739]             }
[17:28:21.739]         }
[17:28:21.739]     })
[17:28:21.739]     if (TRUE) {
[17:28:21.739]         base::sink(type = "output", split = FALSE)
[17:28:21.739]         if (TRUE) {
[17:28:21.739]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.739]         }
[17:28:21.739]         else {
[17:28:21.739]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.739]         }
[17:28:21.739]         base::close(...future.stdout)
[17:28:21.739]         ...future.stdout <- NULL
[17:28:21.739]     }
[17:28:21.739]     ...future.result$conditions <- ...future.conditions
[17:28:21.739]     ...future.result$finished <- base::Sys.time()
[17:28:21.739]     ...future.result
[17:28:21.739] }
[17:28:21.745] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:21.745] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:21.746] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:21.746] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:21.747] MultisessionFuture started
[17:28:21.747] - Launch lazy future ... done
[17:28:21.749] run() for 'MultisessionFuture' ... done
[17:28:21.750] getGlobalsAndPackages() ...
[17:28:21.750] Searching for globals...
[17:28:21.751] - globals found: [3] '{', 'sample', 'x'
[17:28:21.752] Searching for globals ... DONE
[17:28:21.752] Resolving globals: FALSE
[17:28:21.752] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.753] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.753] - globals: [1] 'x'
[17:28:21.753] 
[17:28:21.753] getGlobalsAndPackages() ... DONE
[17:28:21.753] run() for 'Future' ...
[17:28:21.754] - state: 'created'
[17:28:21.754] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.768] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.768] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.768]   - Field: 'node'
[17:28:21.768]   - Field: 'label'
[17:28:21.768]   - Field: 'local'
[17:28:21.768]   - Field: 'owner'
[17:28:21.769]   - Field: 'envir'
[17:28:21.769]   - Field: 'workers'
[17:28:21.769]   - Field: 'packages'
[17:28:21.769]   - Field: 'gc'
[17:28:21.769]   - Field: 'conditions'
[17:28:21.770]   - Field: 'persistent'
[17:28:21.770]   - Field: 'expr'
[17:28:21.770]   - Field: 'uuid'
[17:28:21.770]   - Field: 'seed'
[17:28:21.770]   - Field: 'version'
[17:28:21.770]   - Field: 'result'
[17:28:21.771]   - Field: 'asynchronous'
[17:28:21.771]   - Field: 'calls'
[17:28:21.771]   - Field: 'globals'
[17:28:21.771]   - Field: 'stdout'
[17:28:21.771]   - Field: 'earlySignal'
[17:28:21.771]   - Field: 'lazy'
[17:28:21.772]   - Field: 'state'
[17:28:21.772] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.772] - Launch lazy future ...
[17:28:21.772] Packages needed by the future expression (n = 0): <none>
[17:28:21.772] Packages needed by future strategies (n = 0): <none>
[17:28:21.773] {
[17:28:21.773]     {
[17:28:21.773]         {
[17:28:21.773]             ...future.startTime <- base::Sys.time()
[17:28:21.773]             {
[17:28:21.773]                 {
[17:28:21.773]                   {
[17:28:21.773]                     {
[17:28:21.773]                       base::local({
[17:28:21.773]                         has_future <- base::requireNamespace("future", 
[17:28:21.773]                           quietly = TRUE)
[17:28:21.773]                         if (has_future) {
[17:28:21.773]                           ns <- base::getNamespace("future")
[17:28:21.773]                           version <- ns[[".package"]][["version"]]
[17:28:21.773]                           if (is.null(version)) 
[17:28:21.773]                             version <- utils::packageVersion("future")
[17:28:21.773]                         }
[17:28:21.773]                         else {
[17:28:21.773]                           version <- NULL
[17:28:21.773]                         }
[17:28:21.773]                         if (!has_future || version < "1.8.0") {
[17:28:21.773]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.773]                             "", base::R.version$version.string), 
[17:28:21.773]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:21.773]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:21.773]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.773]                               "release", "version")], collapse = " "), 
[17:28:21.773]                             hostname = base::Sys.info()[["nodename"]])
[17:28:21.773]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.773]                             info)
[17:28:21.773]                           info <- base::paste(info, collapse = "; ")
[17:28:21.773]                           if (!has_future) {
[17:28:21.773]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.773]                               info)
[17:28:21.773]                           }
[17:28:21.773]                           else {
[17:28:21.773]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.773]                               info, version)
[17:28:21.773]                           }
[17:28:21.773]                           base::stop(msg)
[17:28:21.773]                         }
[17:28:21.773]                       })
[17:28:21.773]                     }
[17:28:21.773]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.773]                     base::options(mc.cores = 1L)
[17:28:21.773]                   }
[17:28:21.773]                   ...future.strategy.old <- future::plan("list")
[17:28:21.773]                   options(future.plan = NULL)
[17:28:21.773]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.773]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:21.773]                 }
[17:28:21.773]                 ...future.workdir <- getwd()
[17:28:21.773]             }
[17:28:21.773]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.773]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.773]         }
[17:28:21.773]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.773]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.773]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.773]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.773]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.773]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.773]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.773]             base::names(...future.oldOptions))
[17:28:21.773]     }
[17:28:21.773]     if (FALSE) {
[17:28:21.773]     }
[17:28:21.773]     else {
[17:28:21.773]         if (TRUE) {
[17:28:21.773]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.773]                 open = "w")
[17:28:21.773]         }
[17:28:21.773]         else {
[17:28:21.773]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.773]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.773]         }
[17:28:21.773]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.773]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.773]             base::sink(type = "output", split = FALSE)
[17:28:21.773]             base::close(...future.stdout)
[17:28:21.773]         }, add = TRUE)
[17:28:21.773]     }
[17:28:21.773]     ...future.frame <- base::sys.nframe()
[17:28:21.773]     ...future.conditions <- base::list()
[17:28:21.773]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.773]     if (FALSE) {
[17:28:21.773]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.773]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.773]     }
[17:28:21.773]     ...future.result <- base::tryCatch({
[17:28:21.773]         base::withCallingHandlers({
[17:28:21.773]             ...future.value <- base::withVisible(base::local({
[17:28:21.773]                 ...future.makeSendCondition <- base::local({
[17:28:21.773]                   sendCondition <- NULL
[17:28:21.773]                   function(frame = 1L) {
[17:28:21.773]                     if (is.function(sendCondition)) 
[17:28:21.773]                       return(sendCondition)
[17:28:21.773]                     ns <- getNamespace("parallel")
[17:28:21.773]                     if (exists("sendData", mode = "function", 
[17:28:21.773]                       envir = ns)) {
[17:28:21.773]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.773]                         envir = ns)
[17:28:21.773]                       envir <- sys.frame(frame)
[17:28:21.773]                       master <- NULL
[17:28:21.773]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.773]                         !identical(envir, emptyenv())) {
[17:28:21.773]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.773]                           inherits = FALSE)) {
[17:28:21.773]                           master <- get("master", mode = "list", 
[17:28:21.773]                             envir = envir, inherits = FALSE)
[17:28:21.773]                           if (inherits(master, c("SOCKnode", 
[17:28:21.773]                             "SOCK0node"))) {
[17:28:21.773]                             sendCondition <<- function(cond) {
[17:28:21.773]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.773]                                 success = TRUE)
[17:28:21.773]                               parallel_sendData(master, data)
[17:28:21.773]                             }
[17:28:21.773]                             return(sendCondition)
[17:28:21.773]                           }
[17:28:21.773]                         }
[17:28:21.773]                         frame <- frame + 1L
[17:28:21.773]                         envir <- sys.frame(frame)
[17:28:21.773]                       }
[17:28:21.773]                     }
[17:28:21.773]                     sendCondition <<- function(cond) NULL
[17:28:21.773]                   }
[17:28:21.773]                 })
[17:28:21.773]                 withCallingHandlers({
[17:28:21.773]                   {
[17:28:21.773]                     sample(x, size = 1L)
[17:28:21.773]                   }
[17:28:21.773]                 }, immediateCondition = function(cond) {
[17:28:21.773]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.773]                   sendCondition(cond)
[17:28:21.773]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.773]                   {
[17:28:21.773]                     inherits <- base::inherits
[17:28:21.773]                     invokeRestart <- base::invokeRestart
[17:28:21.773]                     is.null <- base::is.null
[17:28:21.773]                     muffled <- FALSE
[17:28:21.773]                     if (inherits(cond, "message")) {
[17:28:21.773]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.773]                       if (muffled) 
[17:28:21.773]                         invokeRestart("muffleMessage")
[17:28:21.773]                     }
[17:28:21.773]                     else if (inherits(cond, "warning")) {
[17:28:21.773]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.773]                       if (muffled) 
[17:28:21.773]                         invokeRestart("muffleWarning")
[17:28:21.773]                     }
[17:28:21.773]                     else if (inherits(cond, "condition")) {
[17:28:21.773]                       if (!is.null(pattern)) {
[17:28:21.773]                         computeRestarts <- base::computeRestarts
[17:28:21.773]                         grepl <- base::grepl
[17:28:21.773]                         restarts <- computeRestarts(cond)
[17:28:21.773]                         for (restart in restarts) {
[17:28:21.773]                           name <- restart$name
[17:28:21.773]                           if (is.null(name)) 
[17:28:21.773]                             next
[17:28:21.773]                           if (!grepl(pattern, name)) 
[17:28:21.773]                             next
[17:28:21.773]                           invokeRestart(restart)
[17:28:21.773]                           muffled <- TRUE
[17:28:21.773]                           break
[17:28:21.773]                         }
[17:28:21.773]                       }
[17:28:21.773]                     }
[17:28:21.773]                     invisible(muffled)
[17:28:21.773]                   }
[17:28:21.773]                   muffleCondition(cond)
[17:28:21.773]                 })
[17:28:21.773]             }))
[17:28:21.773]             future::FutureResult(value = ...future.value$value, 
[17:28:21.773]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.773]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.773]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.773]                     ...future.globalenv.names))
[17:28:21.773]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.773]         }, condition = base::local({
[17:28:21.773]             c <- base::c
[17:28:21.773]             inherits <- base::inherits
[17:28:21.773]             invokeRestart <- base::invokeRestart
[17:28:21.773]             length <- base::length
[17:28:21.773]             list <- base::list
[17:28:21.773]             seq.int <- base::seq.int
[17:28:21.773]             signalCondition <- base::signalCondition
[17:28:21.773]             sys.calls <- base::sys.calls
[17:28:21.773]             `[[` <- base::`[[`
[17:28:21.773]             `+` <- base::`+`
[17:28:21.773]             `<<-` <- base::`<<-`
[17:28:21.773]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.773]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.773]                   3L)]
[17:28:21.773]             }
[17:28:21.773]             function(cond) {
[17:28:21.773]                 is_error <- inherits(cond, "error")
[17:28:21.773]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.773]                   NULL)
[17:28:21.773]                 if (is_error) {
[17:28:21.773]                   sessionInformation <- function() {
[17:28:21.773]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.773]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.773]                       search = base::search(), system = base::Sys.info())
[17:28:21.773]                   }
[17:28:21.773]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.773]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.773]                     cond$call), session = sessionInformation(), 
[17:28:21.773]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.773]                   signalCondition(cond)
[17:28:21.773]                 }
[17:28:21.773]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.773]                 "immediateCondition"))) {
[17:28:21.773]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.773]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.773]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.773]                   if (TRUE && !signal) {
[17:28:21.773]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.773]                     {
[17:28:21.773]                       inherits <- base::inherits
[17:28:21.773]                       invokeRestart <- base::invokeRestart
[17:28:21.773]                       is.null <- base::is.null
[17:28:21.773]                       muffled <- FALSE
[17:28:21.773]                       if (inherits(cond, "message")) {
[17:28:21.773]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.773]                         if (muffled) 
[17:28:21.773]                           invokeRestart("muffleMessage")
[17:28:21.773]                       }
[17:28:21.773]                       else if (inherits(cond, "warning")) {
[17:28:21.773]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.773]                         if (muffled) 
[17:28:21.773]                           invokeRestart("muffleWarning")
[17:28:21.773]                       }
[17:28:21.773]                       else if (inherits(cond, "condition")) {
[17:28:21.773]                         if (!is.null(pattern)) {
[17:28:21.773]                           computeRestarts <- base::computeRestarts
[17:28:21.773]                           grepl <- base::grepl
[17:28:21.773]                           restarts <- computeRestarts(cond)
[17:28:21.773]                           for (restart in restarts) {
[17:28:21.773]                             name <- restart$name
[17:28:21.773]                             if (is.null(name)) 
[17:28:21.773]                               next
[17:28:21.773]                             if (!grepl(pattern, name)) 
[17:28:21.773]                               next
[17:28:21.773]                             invokeRestart(restart)
[17:28:21.773]                             muffled <- TRUE
[17:28:21.773]                             break
[17:28:21.773]                           }
[17:28:21.773]                         }
[17:28:21.773]                       }
[17:28:21.773]                       invisible(muffled)
[17:28:21.773]                     }
[17:28:21.773]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.773]                   }
[17:28:21.773]                 }
[17:28:21.773]                 else {
[17:28:21.773]                   if (TRUE) {
[17:28:21.773]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.773]                     {
[17:28:21.773]                       inherits <- base::inherits
[17:28:21.773]                       invokeRestart <- base::invokeRestart
[17:28:21.773]                       is.null <- base::is.null
[17:28:21.773]                       muffled <- FALSE
[17:28:21.773]                       if (inherits(cond, "message")) {
[17:28:21.773]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.773]                         if (muffled) 
[17:28:21.773]                           invokeRestart("muffleMessage")
[17:28:21.773]                       }
[17:28:21.773]                       else if (inherits(cond, "warning")) {
[17:28:21.773]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.773]                         if (muffled) 
[17:28:21.773]                           invokeRestart("muffleWarning")
[17:28:21.773]                       }
[17:28:21.773]                       else if (inherits(cond, "condition")) {
[17:28:21.773]                         if (!is.null(pattern)) {
[17:28:21.773]                           computeRestarts <- base::computeRestarts
[17:28:21.773]                           grepl <- base::grepl
[17:28:21.773]                           restarts <- computeRestarts(cond)
[17:28:21.773]                           for (restart in restarts) {
[17:28:21.773]                             name <- restart$name
[17:28:21.773]                             if (is.null(name)) 
[17:28:21.773]                               next
[17:28:21.773]                             if (!grepl(pattern, name)) 
[17:28:21.773]                               next
[17:28:21.773]                             invokeRestart(restart)
[17:28:21.773]                             muffled <- TRUE
[17:28:21.773]                             break
[17:28:21.773]                           }
[17:28:21.773]                         }
[17:28:21.773]                       }
[17:28:21.773]                       invisible(muffled)
[17:28:21.773]                     }
[17:28:21.773]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.773]                   }
[17:28:21.773]                 }
[17:28:21.773]             }
[17:28:21.773]         }))
[17:28:21.773]     }, error = function(ex) {
[17:28:21.773]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.773]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.773]                 ...future.rng), started = ...future.startTime, 
[17:28:21.773]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.773]             version = "1.8"), class = "FutureResult")
[17:28:21.773]     }, finally = {
[17:28:21.773]         if (!identical(...future.workdir, getwd())) 
[17:28:21.773]             setwd(...future.workdir)
[17:28:21.773]         {
[17:28:21.773]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.773]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.773]             }
[17:28:21.773]             base::options(...future.oldOptions)
[17:28:21.773]             if (.Platform$OS.type == "windows") {
[17:28:21.773]                 old_names <- names(...future.oldEnvVars)
[17:28:21.773]                 envs <- base::Sys.getenv()
[17:28:21.773]                 names <- names(envs)
[17:28:21.773]                 common <- intersect(names, old_names)
[17:28:21.773]                 added <- setdiff(names, old_names)
[17:28:21.773]                 removed <- setdiff(old_names, names)
[17:28:21.773]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.773]                   envs[common]]
[17:28:21.773]                 NAMES <- toupper(changed)
[17:28:21.773]                 args <- list()
[17:28:21.773]                 for (kk in seq_along(NAMES)) {
[17:28:21.773]                   name <- changed[[kk]]
[17:28:21.773]                   NAME <- NAMES[[kk]]
[17:28:21.773]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.773]                     next
[17:28:21.773]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.773]                 }
[17:28:21.773]                 NAMES <- toupper(added)
[17:28:21.773]                 for (kk in seq_along(NAMES)) {
[17:28:21.773]                   name <- added[[kk]]
[17:28:21.773]                   NAME <- NAMES[[kk]]
[17:28:21.773]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.773]                     next
[17:28:21.773]                   args[[name]] <- ""
[17:28:21.773]                 }
[17:28:21.773]                 NAMES <- toupper(removed)
[17:28:21.773]                 for (kk in seq_along(NAMES)) {
[17:28:21.773]                   name <- removed[[kk]]
[17:28:21.773]                   NAME <- NAMES[[kk]]
[17:28:21.773]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.773]                     next
[17:28:21.773]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.773]                 }
[17:28:21.773]                 if (length(args) > 0) 
[17:28:21.773]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.773]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.773]             }
[17:28:21.773]             else {
[17:28:21.773]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.773]             }
[17:28:21.773]             {
[17:28:21.773]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.773]                   0L) {
[17:28:21.773]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.773]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.773]                   base::options(opts)
[17:28:21.773]                 }
[17:28:21.773]                 {
[17:28:21.773]                   {
[17:28:21.773]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.773]                     NULL
[17:28:21.773]                   }
[17:28:21.773]                   options(future.plan = NULL)
[17:28:21.773]                   if (is.na(NA_character_)) 
[17:28:21.773]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.773]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.773]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.773]                     .init = FALSE)
[17:28:21.773]                 }
[17:28:21.773]             }
[17:28:21.773]         }
[17:28:21.773]     })
[17:28:21.773]     if (TRUE) {
[17:28:21.773]         base::sink(type = "output", split = FALSE)
[17:28:21.773]         if (TRUE) {
[17:28:21.773]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.773]         }
[17:28:21.773]         else {
[17:28:21.773]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.773]         }
[17:28:21.773]         base::close(...future.stdout)
[17:28:21.773]         ...future.stdout <- NULL
[17:28:21.773]     }
[17:28:21.773]     ...future.result$conditions <- ...future.conditions
[17:28:21.773]     ...future.result$finished <- base::Sys.time()
[17:28:21.773]     ...future.result
[17:28:21.773] }
[17:28:21.778] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:21.789] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.789] - Validating connection of MultisessionFuture
[17:28:21.789] - received message: FutureResult
[17:28:21.789] - Received FutureResult
[17:28:21.790] - Erased future from FutureRegistry
[17:28:21.790] result() for ClusterFuture ...
[17:28:21.790] - result already collected: FutureResult
[17:28:21.790] result() for ClusterFuture ... done
[17:28:21.790] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:21.790] result() for ClusterFuture ...
[17:28:21.791] - result already collected: FutureResult
[17:28:21.791] result() for ClusterFuture ... done
[17:28:21.791] result() for ClusterFuture ...
[17:28:21.791] - result already collected: FutureResult
[17:28:21.791] result() for ClusterFuture ... done
[17:28:21.792] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:21.792] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:21.793] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:21.793] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:21.793] MultisessionFuture started
[17:28:21.794] - Launch lazy future ... done
[17:28:21.794] run() for 'MultisessionFuture' ... done
[17:28:21.794] getGlobalsAndPackages() ...
[17:28:21.794] Searching for globals...
[17:28:21.796] - globals found: [3] '{', 'sample', 'x'
[17:28:21.796] Searching for globals ... DONE
[17:28:21.796] Resolving globals: FALSE
[17:28:21.796] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.797] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.797] - globals: [1] 'x'
[17:28:21.797] 
[17:28:21.797] getGlobalsAndPackages() ... DONE
[17:28:21.798] run() for 'Future' ...
[17:28:21.798] - state: 'created'
[17:28:21.798] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.813] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.813] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.813]   - Field: 'node'
[17:28:21.813]   - Field: 'label'
[17:28:21.814]   - Field: 'local'
[17:28:21.814]   - Field: 'owner'
[17:28:21.814]   - Field: 'envir'
[17:28:21.814]   - Field: 'workers'
[17:28:21.814]   - Field: 'packages'
[17:28:21.814]   - Field: 'gc'
[17:28:21.815]   - Field: 'conditions'
[17:28:21.815]   - Field: 'persistent'
[17:28:21.815]   - Field: 'expr'
[17:28:21.815]   - Field: 'uuid'
[17:28:21.815]   - Field: 'seed'
[17:28:21.815]   - Field: 'version'
[17:28:21.816]   - Field: 'result'
[17:28:21.816]   - Field: 'asynchronous'
[17:28:21.816]   - Field: 'calls'
[17:28:21.816]   - Field: 'globals'
[17:28:21.816]   - Field: 'stdout'
[17:28:21.817]   - Field: 'earlySignal'
[17:28:21.817]   - Field: 'lazy'
[17:28:21.817]   - Field: 'state'
[17:28:21.817] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.817] - Launch lazy future ...
[17:28:21.818] Packages needed by the future expression (n = 0): <none>
[17:28:21.818] Packages needed by future strategies (n = 0): <none>
[17:28:21.818] {
[17:28:21.818]     {
[17:28:21.818]         {
[17:28:21.818]             ...future.startTime <- base::Sys.time()
[17:28:21.818]             {
[17:28:21.818]                 {
[17:28:21.818]                   {
[17:28:21.818]                     {
[17:28:21.818]                       base::local({
[17:28:21.818]                         has_future <- base::requireNamespace("future", 
[17:28:21.818]                           quietly = TRUE)
[17:28:21.818]                         if (has_future) {
[17:28:21.818]                           ns <- base::getNamespace("future")
[17:28:21.818]                           version <- ns[[".package"]][["version"]]
[17:28:21.818]                           if (is.null(version)) 
[17:28:21.818]                             version <- utils::packageVersion("future")
[17:28:21.818]                         }
[17:28:21.818]                         else {
[17:28:21.818]                           version <- NULL
[17:28:21.818]                         }
[17:28:21.818]                         if (!has_future || version < "1.8.0") {
[17:28:21.818]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.818]                             "", base::R.version$version.string), 
[17:28:21.818]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:21.818]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:21.818]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.818]                               "release", "version")], collapse = " "), 
[17:28:21.818]                             hostname = base::Sys.info()[["nodename"]])
[17:28:21.818]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.818]                             info)
[17:28:21.818]                           info <- base::paste(info, collapse = "; ")
[17:28:21.818]                           if (!has_future) {
[17:28:21.818]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.818]                               info)
[17:28:21.818]                           }
[17:28:21.818]                           else {
[17:28:21.818]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.818]                               info, version)
[17:28:21.818]                           }
[17:28:21.818]                           base::stop(msg)
[17:28:21.818]                         }
[17:28:21.818]                       })
[17:28:21.818]                     }
[17:28:21.818]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.818]                     base::options(mc.cores = 1L)
[17:28:21.818]                   }
[17:28:21.818]                   ...future.strategy.old <- future::plan("list")
[17:28:21.818]                   options(future.plan = NULL)
[17:28:21.818]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.818]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:21.818]                 }
[17:28:21.818]                 ...future.workdir <- getwd()
[17:28:21.818]             }
[17:28:21.818]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.818]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.818]         }
[17:28:21.818]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.818]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.818]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.818]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.818]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.818]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.818]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.818]             base::names(...future.oldOptions))
[17:28:21.818]     }
[17:28:21.818]     if (FALSE) {
[17:28:21.818]     }
[17:28:21.818]     else {
[17:28:21.818]         if (TRUE) {
[17:28:21.818]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.818]                 open = "w")
[17:28:21.818]         }
[17:28:21.818]         else {
[17:28:21.818]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.818]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.818]         }
[17:28:21.818]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.818]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.818]             base::sink(type = "output", split = FALSE)
[17:28:21.818]             base::close(...future.stdout)
[17:28:21.818]         }, add = TRUE)
[17:28:21.818]     }
[17:28:21.818]     ...future.frame <- base::sys.nframe()
[17:28:21.818]     ...future.conditions <- base::list()
[17:28:21.818]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.818]     if (FALSE) {
[17:28:21.818]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.818]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.818]     }
[17:28:21.818]     ...future.result <- base::tryCatch({
[17:28:21.818]         base::withCallingHandlers({
[17:28:21.818]             ...future.value <- base::withVisible(base::local({
[17:28:21.818]                 ...future.makeSendCondition <- base::local({
[17:28:21.818]                   sendCondition <- NULL
[17:28:21.818]                   function(frame = 1L) {
[17:28:21.818]                     if (is.function(sendCondition)) 
[17:28:21.818]                       return(sendCondition)
[17:28:21.818]                     ns <- getNamespace("parallel")
[17:28:21.818]                     if (exists("sendData", mode = "function", 
[17:28:21.818]                       envir = ns)) {
[17:28:21.818]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.818]                         envir = ns)
[17:28:21.818]                       envir <- sys.frame(frame)
[17:28:21.818]                       master <- NULL
[17:28:21.818]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.818]                         !identical(envir, emptyenv())) {
[17:28:21.818]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.818]                           inherits = FALSE)) {
[17:28:21.818]                           master <- get("master", mode = "list", 
[17:28:21.818]                             envir = envir, inherits = FALSE)
[17:28:21.818]                           if (inherits(master, c("SOCKnode", 
[17:28:21.818]                             "SOCK0node"))) {
[17:28:21.818]                             sendCondition <<- function(cond) {
[17:28:21.818]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.818]                                 success = TRUE)
[17:28:21.818]                               parallel_sendData(master, data)
[17:28:21.818]                             }
[17:28:21.818]                             return(sendCondition)
[17:28:21.818]                           }
[17:28:21.818]                         }
[17:28:21.818]                         frame <- frame + 1L
[17:28:21.818]                         envir <- sys.frame(frame)
[17:28:21.818]                       }
[17:28:21.818]                     }
[17:28:21.818]                     sendCondition <<- function(cond) NULL
[17:28:21.818]                   }
[17:28:21.818]                 })
[17:28:21.818]                 withCallingHandlers({
[17:28:21.818]                   {
[17:28:21.818]                     sample(x, size = 1L)
[17:28:21.818]                   }
[17:28:21.818]                 }, immediateCondition = function(cond) {
[17:28:21.818]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.818]                   sendCondition(cond)
[17:28:21.818]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.818]                   {
[17:28:21.818]                     inherits <- base::inherits
[17:28:21.818]                     invokeRestart <- base::invokeRestart
[17:28:21.818]                     is.null <- base::is.null
[17:28:21.818]                     muffled <- FALSE
[17:28:21.818]                     if (inherits(cond, "message")) {
[17:28:21.818]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.818]                       if (muffled) 
[17:28:21.818]                         invokeRestart("muffleMessage")
[17:28:21.818]                     }
[17:28:21.818]                     else if (inherits(cond, "warning")) {
[17:28:21.818]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.818]                       if (muffled) 
[17:28:21.818]                         invokeRestart("muffleWarning")
[17:28:21.818]                     }
[17:28:21.818]                     else if (inherits(cond, "condition")) {
[17:28:21.818]                       if (!is.null(pattern)) {
[17:28:21.818]                         computeRestarts <- base::computeRestarts
[17:28:21.818]                         grepl <- base::grepl
[17:28:21.818]                         restarts <- computeRestarts(cond)
[17:28:21.818]                         for (restart in restarts) {
[17:28:21.818]                           name <- restart$name
[17:28:21.818]                           if (is.null(name)) 
[17:28:21.818]                             next
[17:28:21.818]                           if (!grepl(pattern, name)) 
[17:28:21.818]                             next
[17:28:21.818]                           invokeRestart(restart)
[17:28:21.818]                           muffled <- TRUE
[17:28:21.818]                           break
[17:28:21.818]                         }
[17:28:21.818]                       }
[17:28:21.818]                     }
[17:28:21.818]                     invisible(muffled)
[17:28:21.818]                   }
[17:28:21.818]                   muffleCondition(cond)
[17:28:21.818]                 })
[17:28:21.818]             }))
[17:28:21.818]             future::FutureResult(value = ...future.value$value, 
[17:28:21.818]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.818]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.818]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.818]                     ...future.globalenv.names))
[17:28:21.818]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.818]         }, condition = base::local({
[17:28:21.818]             c <- base::c
[17:28:21.818]             inherits <- base::inherits
[17:28:21.818]             invokeRestart <- base::invokeRestart
[17:28:21.818]             length <- base::length
[17:28:21.818]             list <- base::list
[17:28:21.818]             seq.int <- base::seq.int
[17:28:21.818]             signalCondition <- base::signalCondition
[17:28:21.818]             sys.calls <- base::sys.calls
[17:28:21.818]             `[[` <- base::`[[`
[17:28:21.818]             `+` <- base::`+`
[17:28:21.818]             `<<-` <- base::`<<-`
[17:28:21.818]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.818]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.818]                   3L)]
[17:28:21.818]             }
[17:28:21.818]             function(cond) {
[17:28:21.818]                 is_error <- inherits(cond, "error")
[17:28:21.818]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.818]                   NULL)
[17:28:21.818]                 if (is_error) {
[17:28:21.818]                   sessionInformation <- function() {
[17:28:21.818]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.818]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.818]                       search = base::search(), system = base::Sys.info())
[17:28:21.818]                   }
[17:28:21.818]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.818]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.818]                     cond$call), session = sessionInformation(), 
[17:28:21.818]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.818]                   signalCondition(cond)
[17:28:21.818]                 }
[17:28:21.818]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.818]                 "immediateCondition"))) {
[17:28:21.818]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.818]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.818]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.818]                   if (TRUE && !signal) {
[17:28:21.818]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.818]                     {
[17:28:21.818]                       inherits <- base::inherits
[17:28:21.818]                       invokeRestart <- base::invokeRestart
[17:28:21.818]                       is.null <- base::is.null
[17:28:21.818]                       muffled <- FALSE
[17:28:21.818]                       if (inherits(cond, "message")) {
[17:28:21.818]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.818]                         if (muffled) 
[17:28:21.818]                           invokeRestart("muffleMessage")
[17:28:21.818]                       }
[17:28:21.818]                       else if (inherits(cond, "warning")) {
[17:28:21.818]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.818]                         if (muffled) 
[17:28:21.818]                           invokeRestart("muffleWarning")
[17:28:21.818]                       }
[17:28:21.818]                       else if (inherits(cond, "condition")) {
[17:28:21.818]                         if (!is.null(pattern)) {
[17:28:21.818]                           computeRestarts <- base::computeRestarts
[17:28:21.818]                           grepl <- base::grepl
[17:28:21.818]                           restarts <- computeRestarts(cond)
[17:28:21.818]                           for (restart in restarts) {
[17:28:21.818]                             name <- restart$name
[17:28:21.818]                             if (is.null(name)) 
[17:28:21.818]                               next
[17:28:21.818]                             if (!grepl(pattern, name)) 
[17:28:21.818]                               next
[17:28:21.818]                             invokeRestart(restart)
[17:28:21.818]                             muffled <- TRUE
[17:28:21.818]                             break
[17:28:21.818]                           }
[17:28:21.818]                         }
[17:28:21.818]                       }
[17:28:21.818]                       invisible(muffled)
[17:28:21.818]                     }
[17:28:21.818]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.818]                   }
[17:28:21.818]                 }
[17:28:21.818]                 else {
[17:28:21.818]                   if (TRUE) {
[17:28:21.818]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.818]                     {
[17:28:21.818]                       inherits <- base::inherits
[17:28:21.818]                       invokeRestart <- base::invokeRestart
[17:28:21.818]                       is.null <- base::is.null
[17:28:21.818]                       muffled <- FALSE
[17:28:21.818]                       if (inherits(cond, "message")) {
[17:28:21.818]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.818]                         if (muffled) 
[17:28:21.818]                           invokeRestart("muffleMessage")
[17:28:21.818]                       }
[17:28:21.818]                       else if (inherits(cond, "warning")) {
[17:28:21.818]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.818]                         if (muffled) 
[17:28:21.818]                           invokeRestart("muffleWarning")
[17:28:21.818]                       }
[17:28:21.818]                       else if (inherits(cond, "condition")) {
[17:28:21.818]                         if (!is.null(pattern)) {
[17:28:21.818]                           computeRestarts <- base::computeRestarts
[17:28:21.818]                           grepl <- base::grepl
[17:28:21.818]                           restarts <- computeRestarts(cond)
[17:28:21.818]                           for (restart in restarts) {
[17:28:21.818]                             name <- restart$name
[17:28:21.818]                             if (is.null(name)) 
[17:28:21.818]                               next
[17:28:21.818]                             if (!grepl(pattern, name)) 
[17:28:21.818]                               next
[17:28:21.818]                             invokeRestart(restart)
[17:28:21.818]                             muffled <- TRUE
[17:28:21.818]                             break
[17:28:21.818]                           }
[17:28:21.818]                         }
[17:28:21.818]                       }
[17:28:21.818]                       invisible(muffled)
[17:28:21.818]                     }
[17:28:21.818]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.818]                   }
[17:28:21.818]                 }
[17:28:21.818]             }
[17:28:21.818]         }))
[17:28:21.818]     }, error = function(ex) {
[17:28:21.818]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.818]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.818]                 ...future.rng), started = ...future.startTime, 
[17:28:21.818]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.818]             version = "1.8"), class = "FutureResult")
[17:28:21.818]     }, finally = {
[17:28:21.818]         if (!identical(...future.workdir, getwd())) 
[17:28:21.818]             setwd(...future.workdir)
[17:28:21.818]         {
[17:28:21.818]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.818]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.818]             }
[17:28:21.818]             base::options(...future.oldOptions)
[17:28:21.818]             if (.Platform$OS.type == "windows") {
[17:28:21.818]                 old_names <- names(...future.oldEnvVars)
[17:28:21.818]                 envs <- base::Sys.getenv()
[17:28:21.818]                 names <- names(envs)
[17:28:21.818]                 common <- intersect(names, old_names)
[17:28:21.818]                 added <- setdiff(names, old_names)
[17:28:21.818]                 removed <- setdiff(old_names, names)
[17:28:21.818]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.818]                   envs[common]]
[17:28:21.818]                 NAMES <- toupper(changed)
[17:28:21.818]                 args <- list()
[17:28:21.818]                 for (kk in seq_along(NAMES)) {
[17:28:21.818]                   name <- changed[[kk]]
[17:28:21.818]                   NAME <- NAMES[[kk]]
[17:28:21.818]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.818]                     next
[17:28:21.818]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.818]                 }
[17:28:21.818]                 NAMES <- toupper(added)
[17:28:21.818]                 for (kk in seq_along(NAMES)) {
[17:28:21.818]                   name <- added[[kk]]
[17:28:21.818]                   NAME <- NAMES[[kk]]
[17:28:21.818]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.818]                     next
[17:28:21.818]                   args[[name]] <- ""
[17:28:21.818]                 }
[17:28:21.818]                 NAMES <- toupper(removed)
[17:28:21.818]                 for (kk in seq_along(NAMES)) {
[17:28:21.818]                   name <- removed[[kk]]
[17:28:21.818]                   NAME <- NAMES[[kk]]
[17:28:21.818]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.818]                     next
[17:28:21.818]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.818]                 }
[17:28:21.818]                 if (length(args) > 0) 
[17:28:21.818]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.818]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.818]             }
[17:28:21.818]             else {
[17:28:21.818]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.818]             }
[17:28:21.818]             {
[17:28:21.818]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.818]                   0L) {
[17:28:21.818]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.818]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.818]                   base::options(opts)
[17:28:21.818]                 }
[17:28:21.818]                 {
[17:28:21.818]                   {
[17:28:21.818]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.818]                     NULL
[17:28:21.818]                   }
[17:28:21.818]                   options(future.plan = NULL)
[17:28:21.818]                   if (is.na(NA_character_)) 
[17:28:21.818]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.818]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.818]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.818]                     .init = FALSE)
[17:28:21.818]                 }
[17:28:21.818]             }
[17:28:21.818]         }
[17:28:21.818]     })
[17:28:21.818]     if (TRUE) {
[17:28:21.818]         base::sink(type = "output", split = FALSE)
[17:28:21.818]         if (TRUE) {
[17:28:21.818]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.818]         }
[17:28:21.818]         else {
[17:28:21.818]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.818]         }
[17:28:21.818]         base::close(...future.stdout)
[17:28:21.818]         ...future.stdout <- NULL
[17:28:21.818]     }
[17:28:21.818]     ...future.result$conditions <- ...future.conditions
[17:28:21.818]     ...future.result$finished <- base::Sys.time()
[17:28:21.818]     ...future.result
[17:28:21.818] }
[17:28:21.823] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:21.836] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.836] - Validating connection of MultisessionFuture
[17:28:21.836] - received message: FutureResult
[17:28:21.836] - Received FutureResult
[17:28:21.836] - Erased future from FutureRegistry
[17:28:21.837] result() for ClusterFuture ...
[17:28:21.837] - result already collected: FutureResult
[17:28:21.837] result() for ClusterFuture ... done
[17:28:21.837] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:21.837] result() for ClusterFuture ...
[17:28:21.837] - result already collected: FutureResult
[17:28:21.838] result() for ClusterFuture ... done
[17:28:21.838] result() for ClusterFuture ...
[17:28:21.838] - result already collected: FutureResult
[17:28:21.838] result() for ClusterFuture ... done
[17:28:21.839] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:21.839] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:21.840] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:21.840] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:21.840] MultisessionFuture started
[17:28:21.841] - Launch lazy future ... done
[17:28:21.841] run() for 'MultisessionFuture' ... done
[17:28:21.841] result() for ClusterFuture ...
[17:28:21.841] - result already collected: FutureResult
[17:28:21.841] result() for ClusterFuture ... done
[17:28:21.842] result() for ClusterFuture ...
[17:28:21.842] - result already collected: FutureResult
[17:28:21.842] result() for ClusterFuture ... done
[17:28:21.842] result() for ClusterFuture ...
[17:28:21.842] - result already collected: FutureResult
[17:28:21.842] result() for ClusterFuture ... done
[17:28:21.843] result() for ClusterFuture ...
[17:28:21.843] - result already collected: FutureResult
[17:28:21.843] result() for ClusterFuture ... done
[17:28:21.843] result() for ClusterFuture ...
[17:28:21.843] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.843] - Validating connection of MultisessionFuture
[17:28:21.844] - received message: FutureResult
[17:28:21.844] - Received FutureResult
[17:28:21.844] - Erased future from FutureRegistry
[17:28:21.844] result() for ClusterFuture ...
[17:28:21.844] - result already collected: FutureResult
[17:28:21.844] result() for ClusterFuture ... done
[17:28:21.845] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:21.845] result() for ClusterFuture ... done
[17:28:21.845] result() for ClusterFuture ...
[17:28:21.845] - result already collected: FutureResult
[17:28:21.845] result() for ClusterFuture ... done
[17:28:21.846] result() for ClusterFuture ...
[17:28:21.846] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.846] - Validating connection of MultisessionFuture
[17:28:21.856] - received message: FutureResult
[17:28:21.856] - Received FutureResult
[17:28:21.856] - Erased future from FutureRegistry
[17:28:21.856] result() for ClusterFuture ...
[17:28:21.856] - result already collected: FutureResult
[17:28:21.857] result() for ClusterFuture ... done
[17:28:21.857] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:21.857] result() for ClusterFuture ... done
[17:28:21.857] result() for ClusterFuture ...
[17:28:21.857] - result already collected: FutureResult
[17:28:21.857] result() for ClusterFuture ... done
[[1]]
[1] 1

[[2]]
[1] 1

[[3]]
[1] 2

[[4]]
[1] 3

[17:28:21.858] getGlobalsAndPackages() ...
[17:28:21.858] Searching for globals...
[17:28:21.859] - globals found: [3] '{', 'sample', 'x'
[17:28:21.860] Searching for globals ... DONE
[17:28:21.860] Resolving globals: FALSE
[17:28:21.860] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.861] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.861] - globals: [1] 'x'
[17:28:21.861] 
[17:28:21.861] getGlobalsAndPackages() ... DONE
[17:28:21.862] run() for 'Future' ...
[17:28:21.862] - state: 'created'
[17:28:21.862] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.875] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.875] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.876]   - Field: 'node'
[17:28:21.876]   - Field: 'label'
[17:28:21.876]   - Field: 'local'
[17:28:21.876]   - Field: 'owner'
[17:28:21.876]   - Field: 'envir'
[17:28:21.877]   - Field: 'workers'
[17:28:21.877]   - Field: 'packages'
[17:28:21.877]   - Field: 'gc'
[17:28:21.877]   - Field: 'conditions'
[17:28:21.877]   - Field: 'persistent'
[17:28:21.877]   - Field: 'expr'
[17:28:21.878]   - Field: 'uuid'
[17:28:21.878]   - Field: 'seed'
[17:28:21.878]   - Field: 'version'
[17:28:21.878]   - Field: 'result'
[17:28:21.878]   - Field: 'asynchronous'
[17:28:21.878]   - Field: 'calls'
[17:28:21.879]   - Field: 'globals'
[17:28:21.879]   - Field: 'stdout'
[17:28:21.879]   - Field: 'earlySignal'
[17:28:21.879]   - Field: 'lazy'
[17:28:21.879]   - Field: 'state'
[17:28:21.880] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.880] - Launch lazy future ...
[17:28:21.880] Packages needed by the future expression (n = 0): <none>
[17:28:21.880] Packages needed by future strategies (n = 0): <none>
[17:28:21.881] {
[17:28:21.881]     {
[17:28:21.881]         {
[17:28:21.881]             ...future.startTime <- base::Sys.time()
[17:28:21.881]             {
[17:28:21.881]                 {
[17:28:21.881]                   {
[17:28:21.881]                     {
[17:28:21.881]                       base::local({
[17:28:21.881]                         has_future <- base::requireNamespace("future", 
[17:28:21.881]                           quietly = TRUE)
[17:28:21.881]                         if (has_future) {
[17:28:21.881]                           ns <- base::getNamespace("future")
[17:28:21.881]                           version <- ns[[".package"]][["version"]]
[17:28:21.881]                           if (is.null(version)) 
[17:28:21.881]                             version <- utils::packageVersion("future")
[17:28:21.881]                         }
[17:28:21.881]                         else {
[17:28:21.881]                           version <- NULL
[17:28:21.881]                         }
[17:28:21.881]                         if (!has_future || version < "1.8.0") {
[17:28:21.881]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.881]                             "", base::R.version$version.string), 
[17:28:21.881]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:21.881]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:21.881]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.881]                               "release", "version")], collapse = " "), 
[17:28:21.881]                             hostname = base::Sys.info()[["nodename"]])
[17:28:21.881]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.881]                             info)
[17:28:21.881]                           info <- base::paste(info, collapse = "; ")
[17:28:21.881]                           if (!has_future) {
[17:28:21.881]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.881]                               info)
[17:28:21.881]                           }
[17:28:21.881]                           else {
[17:28:21.881]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.881]                               info, version)
[17:28:21.881]                           }
[17:28:21.881]                           base::stop(msg)
[17:28:21.881]                         }
[17:28:21.881]                       })
[17:28:21.881]                     }
[17:28:21.881]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.881]                     base::options(mc.cores = 1L)
[17:28:21.881]                   }
[17:28:21.881]                   ...future.strategy.old <- future::plan("list")
[17:28:21.881]                   options(future.plan = NULL)
[17:28:21.881]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.881]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:21.881]                 }
[17:28:21.881]                 ...future.workdir <- getwd()
[17:28:21.881]             }
[17:28:21.881]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.881]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.881]         }
[17:28:21.881]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.881]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.881]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.881]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.881]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.881]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.881]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.881]             base::names(...future.oldOptions))
[17:28:21.881]     }
[17:28:21.881]     if (FALSE) {
[17:28:21.881]     }
[17:28:21.881]     else {
[17:28:21.881]         if (TRUE) {
[17:28:21.881]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.881]                 open = "w")
[17:28:21.881]         }
[17:28:21.881]         else {
[17:28:21.881]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.881]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.881]         }
[17:28:21.881]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.881]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.881]             base::sink(type = "output", split = FALSE)
[17:28:21.881]             base::close(...future.stdout)
[17:28:21.881]         }, add = TRUE)
[17:28:21.881]     }
[17:28:21.881]     ...future.frame <- base::sys.nframe()
[17:28:21.881]     ...future.conditions <- base::list()
[17:28:21.881]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.881]     if (FALSE) {
[17:28:21.881]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.881]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.881]     }
[17:28:21.881]     ...future.result <- base::tryCatch({
[17:28:21.881]         base::withCallingHandlers({
[17:28:21.881]             ...future.value <- base::withVisible(base::local({
[17:28:21.881]                 ...future.makeSendCondition <- base::local({
[17:28:21.881]                   sendCondition <- NULL
[17:28:21.881]                   function(frame = 1L) {
[17:28:21.881]                     if (is.function(sendCondition)) 
[17:28:21.881]                       return(sendCondition)
[17:28:21.881]                     ns <- getNamespace("parallel")
[17:28:21.881]                     if (exists("sendData", mode = "function", 
[17:28:21.881]                       envir = ns)) {
[17:28:21.881]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.881]                         envir = ns)
[17:28:21.881]                       envir <- sys.frame(frame)
[17:28:21.881]                       master <- NULL
[17:28:21.881]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.881]                         !identical(envir, emptyenv())) {
[17:28:21.881]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.881]                           inherits = FALSE)) {
[17:28:21.881]                           master <- get("master", mode = "list", 
[17:28:21.881]                             envir = envir, inherits = FALSE)
[17:28:21.881]                           if (inherits(master, c("SOCKnode", 
[17:28:21.881]                             "SOCK0node"))) {
[17:28:21.881]                             sendCondition <<- function(cond) {
[17:28:21.881]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.881]                                 success = TRUE)
[17:28:21.881]                               parallel_sendData(master, data)
[17:28:21.881]                             }
[17:28:21.881]                             return(sendCondition)
[17:28:21.881]                           }
[17:28:21.881]                         }
[17:28:21.881]                         frame <- frame + 1L
[17:28:21.881]                         envir <- sys.frame(frame)
[17:28:21.881]                       }
[17:28:21.881]                     }
[17:28:21.881]                     sendCondition <<- function(cond) NULL
[17:28:21.881]                   }
[17:28:21.881]                 })
[17:28:21.881]                 withCallingHandlers({
[17:28:21.881]                   {
[17:28:21.881]                     sample(x, size = 1L)
[17:28:21.881]                   }
[17:28:21.881]                 }, immediateCondition = function(cond) {
[17:28:21.881]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.881]                   sendCondition(cond)
[17:28:21.881]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.881]                   {
[17:28:21.881]                     inherits <- base::inherits
[17:28:21.881]                     invokeRestart <- base::invokeRestart
[17:28:21.881]                     is.null <- base::is.null
[17:28:21.881]                     muffled <- FALSE
[17:28:21.881]                     if (inherits(cond, "message")) {
[17:28:21.881]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.881]                       if (muffled) 
[17:28:21.881]                         invokeRestart("muffleMessage")
[17:28:21.881]                     }
[17:28:21.881]                     else if (inherits(cond, "warning")) {
[17:28:21.881]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.881]                       if (muffled) 
[17:28:21.881]                         invokeRestart("muffleWarning")
[17:28:21.881]                     }
[17:28:21.881]                     else if (inherits(cond, "condition")) {
[17:28:21.881]                       if (!is.null(pattern)) {
[17:28:21.881]                         computeRestarts <- base::computeRestarts
[17:28:21.881]                         grepl <- base::grepl
[17:28:21.881]                         restarts <- computeRestarts(cond)
[17:28:21.881]                         for (restart in restarts) {
[17:28:21.881]                           name <- restart$name
[17:28:21.881]                           if (is.null(name)) 
[17:28:21.881]                             next
[17:28:21.881]                           if (!grepl(pattern, name)) 
[17:28:21.881]                             next
[17:28:21.881]                           invokeRestart(restart)
[17:28:21.881]                           muffled <- TRUE
[17:28:21.881]                           break
[17:28:21.881]                         }
[17:28:21.881]                       }
[17:28:21.881]                     }
[17:28:21.881]                     invisible(muffled)
[17:28:21.881]                   }
[17:28:21.881]                   muffleCondition(cond)
[17:28:21.881]                 })
[17:28:21.881]             }))
[17:28:21.881]             future::FutureResult(value = ...future.value$value, 
[17:28:21.881]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.881]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.881]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.881]                     ...future.globalenv.names))
[17:28:21.881]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.881]         }, condition = base::local({
[17:28:21.881]             c <- base::c
[17:28:21.881]             inherits <- base::inherits
[17:28:21.881]             invokeRestart <- base::invokeRestart
[17:28:21.881]             length <- base::length
[17:28:21.881]             list <- base::list
[17:28:21.881]             seq.int <- base::seq.int
[17:28:21.881]             signalCondition <- base::signalCondition
[17:28:21.881]             sys.calls <- base::sys.calls
[17:28:21.881]             `[[` <- base::`[[`
[17:28:21.881]             `+` <- base::`+`
[17:28:21.881]             `<<-` <- base::`<<-`
[17:28:21.881]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.881]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.881]                   3L)]
[17:28:21.881]             }
[17:28:21.881]             function(cond) {
[17:28:21.881]                 is_error <- inherits(cond, "error")
[17:28:21.881]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.881]                   NULL)
[17:28:21.881]                 if (is_error) {
[17:28:21.881]                   sessionInformation <- function() {
[17:28:21.881]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.881]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.881]                       search = base::search(), system = base::Sys.info())
[17:28:21.881]                   }
[17:28:21.881]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.881]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.881]                     cond$call), session = sessionInformation(), 
[17:28:21.881]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.881]                   signalCondition(cond)
[17:28:21.881]                 }
[17:28:21.881]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.881]                 "immediateCondition"))) {
[17:28:21.881]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.881]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.881]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.881]                   if (TRUE && !signal) {
[17:28:21.881]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.881]                     {
[17:28:21.881]                       inherits <- base::inherits
[17:28:21.881]                       invokeRestart <- base::invokeRestart
[17:28:21.881]                       is.null <- base::is.null
[17:28:21.881]                       muffled <- FALSE
[17:28:21.881]                       if (inherits(cond, "message")) {
[17:28:21.881]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.881]                         if (muffled) 
[17:28:21.881]                           invokeRestart("muffleMessage")
[17:28:21.881]                       }
[17:28:21.881]                       else if (inherits(cond, "warning")) {
[17:28:21.881]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.881]                         if (muffled) 
[17:28:21.881]                           invokeRestart("muffleWarning")
[17:28:21.881]                       }
[17:28:21.881]                       else if (inherits(cond, "condition")) {
[17:28:21.881]                         if (!is.null(pattern)) {
[17:28:21.881]                           computeRestarts <- base::computeRestarts
[17:28:21.881]                           grepl <- base::grepl
[17:28:21.881]                           restarts <- computeRestarts(cond)
[17:28:21.881]                           for (restart in restarts) {
[17:28:21.881]                             name <- restart$name
[17:28:21.881]                             if (is.null(name)) 
[17:28:21.881]                               next
[17:28:21.881]                             if (!grepl(pattern, name)) 
[17:28:21.881]                               next
[17:28:21.881]                             invokeRestart(restart)
[17:28:21.881]                             muffled <- TRUE
[17:28:21.881]                             break
[17:28:21.881]                           }
[17:28:21.881]                         }
[17:28:21.881]                       }
[17:28:21.881]                       invisible(muffled)
[17:28:21.881]                     }
[17:28:21.881]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.881]                   }
[17:28:21.881]                 }
[17:28:21.881]                 else {
[17:28:21.881]                   if (TRUE) {
[17:28:21.881]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.881]                     {
[17:28:21.881]                       inherits <- base::inherits
[17:28:21.881]                       invokeRestart <- base::invokeRestart
[17:28:21.881]                       is.null <- base::is.null
[17:28:21.881]                       muffled <- FALSE
[17:28:21.881]                       if (inherits(cond, "message")) {
[17:28:21.881]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.881]                         if (muffled) 
[17:28:21.881]                           invokeRestart("muffleMessage")
[17:28:21.881]                       }
[17:28:21.881]                       else if (inherits(cond, "warning")) {
[17:28:21.881]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.881]                         if (muffled) 
[17:28:21.881]                           invokeRestart("muffleWarning")
[17:28:21.881]                       }
[17:28:21.881]                       else if (inherits(cond, "condition")) {
[17:28:21.881]                         if (!is.null(pattern)) {
[17:28:21.881]                           computeRestarts <- base::computeRestarts
[17:28:21.881]                           grepl <- base::grepl
[17:28:21.881]                           restarts <- computeRestarts(cond)
[17:28:21.881]                           for (restart in restarts) {
[17:28:21.881]                             name <- restart$name
[17:28:21.881]                             if (is.null(name)) 
[17:28:21.881]                               next
[17:28:21.881]                             if (!grepl(pattern, name)) 
[17:28:21.881]                               next
[17:28:21.881]                             invokeRestart(restart)
[17:28:21.881]                             muffled <- TRUE
[17:28:21.881]                             break
[17:28:21.881]                           }
[17:28:21.881]                         }
[17:28:21.881]                       }
[17:28:21.881]                       invisible(muffled)
[17:28:21.881]                     }
[17:28:21.881]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.881]                   }
[17:28:21.881]                 }
[17:28:21.881]             }
[17:28:21.881]         }))
[17:28:21.881]     }, error = function(ex) {
[17:28:21.881]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.881]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.881]                 ...future.rng), started = ...future.startTime, 
[17:28:21.881]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.881]             version = "1.8"), class = "FutureResult")
[17:28:21.881]     }, finally = {
[17:28:21.881]         if (!identical(...future.workdir, getwd())) 
[17:28:21.881]             setwd(...future.workdir)
[17:28:21.881]         {
[17:28:21.881]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.881]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.881]             }
[17:28:21.881]             base::options(...future.oldOptions)
[17:28:21.881]             if (.Platform$OS.type == "windows") {
[17:28:21.881]                 old_names <- names(...future.oldEnvVars)
[17:28:21.881]                 envs <- base::Sys.getenv()
[17:28:21.881]                 names <- names(envs)
[17:28:21.881]                 common <- intersect(names, old_names)
[17:28:21.881]                 added <- setdiff(names, old_names)
[17:28:21.881]                 removed <- setdiff(old_names, names)
[17:28:21.881]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.881]                   envs[common]]
[17:28:21.881]                 NAMES <- toupper(changed)
[17:28:21.881]                 args <- list()
[17:28:21.881]                 for (kk in seq_along(NAMES)) {
[17:28:21.881]                   name <- changed[[kk]]
[17:28:21.881]                   NAME <- NAMES[[kk]]
[17:28:21.881]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.881]                     next
[17:28:21.881]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.881]                 }
[17:28:21.881]                 NAMES <- toupper(added)
[17:28:21.881]                 for (kk in seq_along(NAMES)) {
[17:28:21.881]                   name <- added[[kk]]
[17:28:21.881]                   NAME <- NAMES[[kk]]
[17:28:21.881]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.881]                     next
[17:28:21.881]                   args[[name]] <- ""
[17:28:21.881]                 }
[17:28:21.881]                 NAMES <- toupper(removed)
[17:28:21.881]                 for (kk in seq_along(NAMES)) {
[17:28:21.881]                   name <- removed[[kk]]
[17:28:21.881]                   NAME <- NAMES[[kk]]
[17:28:21.881]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.881]                     next
[17:28:21.881]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.881]                 }
[17:28:21.881]                 if (length(args) > 0) 
[17:28:21.881]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.881]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.881]             }
[17:28:21.881]             else {
[17:28:21.881]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.881]             }
[17:28:21.881]             {
[17:28:21.881]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.881]                   0L) {
[17:28:21.881]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.881]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.881]                   base::options(opts)
[17:28:21.881]                 }
[17:28:21.881]                 {
[17:28:21.881]                   {
[17:28:21.881]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.881]                     NULL
[17:28:21.881]                   }
[17:28:21.881]                   options(future.plan = NULL)
[17:28:21.881]                   if (is.na(NA_character_)) 
[17:28:21.881]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.881]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.881]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.881]                     .init = FALSE)
[17:28:21.881]                 }
[17:28:21.881]             }
[17:28:21.881]         }
[17:28:21.881]     })
[17:28:21.881]     if (TRUE) {
[17:28:21.881]         base::sink(type = "output", split = FALSE)
[17:28:21.881]         if (TRUE) {
[17:28:21.881]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.881]         }
[17:28:21.881]         else {
[17:28:21.881]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.881]         }
[17:28:21.881]         base::close(...future.stdout)
[17:28:21.881]         ...future.stdout <- NULL
[17:28:21.881]     }
[17:28:21.881]     ...future.result$conditions <- ...future.conditions
[17:28:21.881]     ...future.result$finished <- base::Sys.time()
[17:28:21.881]     ...future.result
[17:28:21.881] }
[17:28:21.886] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:21.886] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:21.887] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:21.887] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:21.888] MultisessionFuture started
[17:28:21.888] - Launch lazy future ... done
[17:28:21.888] run() for 'MultisessionFuture' ... done
[17:28:21.889] getGlobalsAndPackages() ...
[17:28:21.889] Searching for globals...
[17:28:21.890] - globals found: [3] '{', 'sample', 'x'
[17:28:21.890] Searching for globals ... DONE
[17:28:21.890] Resolving globals: FALSE
[17:28:21.891] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.891] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.891] - globals: [1] 'x'
[17:28:21.892] 
[17:28:21.892] getGlobalsAndPackages() ... DONE
[17:28:21.892] run() for 'Future' ...
[17:28:21.892] - state: 'created'
[17:28:21.892] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.906] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.906] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.906]   - Field: 'node'
[17:28:21.906]   - Field: 'label'
[17:28:21.906]   - Field: 'local'
[17:28:21.907]   - Field: 'owner'
[17:28:21.907]   - Field: 'envir'
[17:28:21.907]   - Field: 'workers'
[17:28:21.907]   - Field: 'packages'
[17:28:21.907]   - Field: 'gc'
[17:28:21.908]   - Field: 'conditions'
[17:28:21.908]   - Field: 'persistent'
[17:28:21.908]   - Field: 'expr'
[17:28:21.908]   - Field: 'uuid'
[17:28:21.908]   - Field: 'seed'
[17:28:21.908]   - Field: 'version'
[17:28:21.909]   - Field: 'result'
[17:28:21.909]   - Field: 'asynchronous'
[17:28:21.909]   - Field: 'calls'
[17:28:21.909]   - Field: 'globals'
[17:28:21.909]   - Field: 'stdout'
[17:28:21.910]   - Field: 'earlySignal'
[17:28:21.910]   - Field: 'lazy'
[17:28:21.910]   - Field: 'state'
[17:28:21.910] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.910] - Launch lazy future ...
[17:28:21.911] Packages needed by the future expression (n = 0): <none>
[17:28:21.911] Packages needed by future strategies (n = 0): <none>
[17:28:21.911] {
[17:28:21.911]     {
[17:28:21.911]         {
[17:28:21.911]             ...future.startTime <- base::Sys.time()
[17:28:21.911]             {
[17:28:21.911]                 {
[17:28:21.911]                   {
[17:28:21.911]                     {
[17:28:21.911]                       base::local({
[17:28:21.911]                         has_future <- base::requireNamespace("future", 
[17:28:21.911]                           quietly = TRUE)
[17:28:21.911]                         if (has_future) {
[17:28:21.911]                           ns <- base::getNamespace("future")
[17:28:21.911]                           version <- ns[[".package"]][["version"]]
[17:28:21.911]                           if (is.null(version)) 
[17:28:21.911]                             version <- utils::packageVersion("future")
[17:28:21.911]                         }
[17:28:21.911]                         else {
[17:28:21.911]                           version <- NULL
[17:28:21.911]                         }
[17:28:21.911]                         if (!has_future || version < "1.8.0") {
[17:28:21.911]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.911]                             "", base::R.version$version.string), 
[17:28:21.911]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:21.911]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:21.911]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.911]                               "release", "version")], collapse = " "), 
[17:28:21.911]                             hostname = base::Sys.info()[["nodename"]])
[17:28:21.911]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.911]                             info)
[17:28:21.911]                           info <- base::paste(info, collapse = "; ")
[17:28:21.911]                           if (!has_future) {
[17:28:21.911]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.911]                               info)
[17:28:21.911]                           }
[17:28:21.911]                           else {
[17:28:21.911]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.911]                               info, version)
[17:28:21.911]                           }
[17:28:21.911]                           base::stop(msg)
[17:28:21.911]                         }
[17:28:21.911]                       })
[17:28:21.911]                     }
[17:28:21.911]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.911]                     base::options(mc.cores = 1L)
[17:28:21.911]                   }
[17:28:21.911]                   ...future.strategy.old <- future::plan("list")
[17:28:21.911]                   options(future.plan = NULL)
[17:28:21.911]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.911]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:21.911]                 }
[17:28:21.911]                 ...future.workdir <- getwd()
[17:28:21.911]             }
[17:28:21.911]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.911]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.911]         }
[17:28:21.911]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.911]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.911]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.911]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.911]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.911]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.911]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.911]             base::names(...future.oldOptions))
[17:28:21.911]     }
[17:28:21.911]     if (FALSE) {
[17:28:21.911]     }
[17:28:21.911]     else {
[17:28:21.911]         if (TRUE) {
[17:28:21.911]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.911]                 open = "w")
[17:28:21.911]         }
[17:28:21.911]         else {
[17:28:21.911]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.911]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.911]         }
[17:28:21.911]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.911]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.911]             base::sink(type = "output", split = FALSE)
[17:28:21.911]             base::close(...future.stdout)
[17:28:21.911]         }, add = TRUE)
[17:28:21.911]     }
[17:28:21.911]     ...future.frame <- base::sys.nframe()
[17:28:21.911]     ...future.conditions <- base::list()
[17:28:21.911]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.911]     if (FALSE) {
[17:28:21.911]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.911]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.911]     }
[17:28:21.911]     ...future.result <- base::tryCatch({
[17:28:21.911]         base::withCallingHandlers({
[17:28:21.911]             ...future.value <- base::withVisible(base::local({
[17:28:21.911]                 ...future.makeSendCondition <- base::local({
[17:28:21.911]                   sendCondition <- NULL
[17:28:21.911]                   function(frame = 1L) {
[17:28:21.911]                     if (is.function(sendCondition)) 
[17:28:21.911]                       return(sendCondition)
[17:28:21.911]                     ns <- getNamespace("parallel")
[17:28:21.911]                     if (exists("sendData", mode = "function", 
[17:28:21.911]                       envir = ns)) {
[17:28:21.911]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.911]                         envir = ns)
[17:28:21.911]                       envir <- sys.frame(frame)
[17:28:21.911]                       master <- NULL
[17:28:21.911]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.911]                         !identical(envir, emptyenv())) {
[17:28:21.911]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.911]                           inherits = FALSE)) {
[17:28:21.911]                           master <- get("master", mode = "list", 
[17:28:21.911]                             envir = envir, inherits = FALSE)
[17:28:21.911]                           if (inherits(master, c("SOCKnode", 
[17:28:21.911]                             "SOCK0node"))) {
[17:28:21.911]                             sendCondition <<- function(cond) {
[17:28:21.911]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.911]                                 success = TRUE)
[17:28:21.911]                               parallel_sendData(master, data)
[17:28:21.911]                             }
[17:28:21.911]                             return(sendCondition)
[17:28:21.911]                           }
[17:28:21.911]                         }
[17:28:21.911]                         frame <- frame + 1L
[17:28:21.911]                         envir <- sys.frame(frame)
[17:28:21.911]                       }
[17:28:21.911]                     }
[17:28:21.911]                     sendCondition <<- function(cond) NULL
[17:28:21.911]                   }
[17:28:21.911]                 })
[17:28:21.911]                 withCallingHandlers({
[17:28:21.911]                   {
[17:28:21.911]                     sample(x, size = 1L)
[17:28:21.911]                   }
[17:28:21.911]                 }, immediateCondition = function(cond) {
[17:28:21.911]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.911]                   sendCondition(cond)
[17:28:21.911]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.911]                   {
[17:28:21.911]                     inherits <- base::inherits
[17:28:21.911]                     invokeRestart <- base::invokeRestart
[17:28:21.911]                     is.null <- base::is.null
[17:28:21.911]                     muffled <- FALSE
[17:28:21.911]                     if (inherits(cond, "message")) {
[17:28:21.911]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.911]                       if (muffled) 
[17:28:21.911]                         invokeRestart("muffleMessage")
[17:28:21.911]                     }
[17:28:21.911]                     else if (inherits(cond, "warning")) {
[17:28:21.911]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.911]                       if (muffled) 
[17:28:21.911]                         invokeRestart("muffleWarning")
[17:28:21.911]                     }
[17:28:21.911]                     else if (inherits(cond, "condition")) {
[17:28:21.911]                       if (!is.null(pattern)) {
[17:28:21.911]                         computeRestarts <- base::computeRestarts
[17:28:21.911]                         grepl <- base::grepl
[17:28:21.911]                         restarts <- computeRestarts(cond)
[17:28:21.911]                         for (restart in restarts) {
[17:28:21.911]                           name <- restart$name
[17:28:21.911]                           if (is.null(name)) 
[17:28:21.911]                             next
[17:28:21.911]                           if (!grepl(pattern, name)) 
[17:28:21.911]                             next
[17:28:21.911]                           invokeRestart(restart)
[17:28:21.911]                           muffled <- TRUE
[17:28:21.911]                           break
[17:28:21.911]                         }
[17:28:21.911]                       }
[17:28:21.911]                     }
[17:28:21.911]                     invisible(muffled)
[17:28:21.911]                   }
[17:28:21.911]                   muffleCondition(cond)
[17:28:21.911]                 })
[17:28:21.911]             }))
[17:28:21.911]             future::FutureResult(value = ...future.value$value, 
[17:28:21.911]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.911]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.911]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.911]                     ...future.globalenv.names))
[17:28:21.911]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.911]         }, condition = base::local({
[17:28:21.911]             c <- base::c
[17:28:21.911]             inherits <- base::inherits
[17:28:21.911]             invokeRestart <- base::invokeRestart
[17:28:21.911]             length <- base::length
[17:28:21.911]             list <- base::list
[17:28:21.911]             seq.int <- base::seq.int
[17:28:21.911]             signalCondition <- base::signalCondition
[17:28:21.911]             sys.calls <- base::sys.calls
[17:28:21.911]             `[[` <- base::`[[`
[17:28:21.911]             `+` <- base::`+`
[17:28:21.911]             `<<-` <- base::`<<-`
[17:28:21.911]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.911]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.911]                   3L)]
[17:28:21.911]             }
[17:28:21.911]             function(cond) {
[17:28:21.911]                 is_error <- inherits(cond, "error")
[17:28:21.911]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.911]                   NULL)
[17:28:21.911]                 if (is_error) {
[17:28:21.911]                   sessionInformation <- function() {
[17:28:21.911]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.911]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.911]                       search = base::search(), system = base::Sys.info())
[17:28:21.911]                   }
[17:28:21.911]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.911]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.911]                     cond$call), session = sessionInformation(), 
[17:28:21.911]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.911]                   signalCondition(cond)
[17:28:21.911]                 }
[17:28:21.911]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.911]                 "immediateCondition"))) {
[17:28:21.911]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.911]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.911]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.911]                   if (TRUE && !signal) {
[17:28:21.911]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.911]                     {
[17:28:21.911]                       inherits <- base::inherits
[17:28:21.911]                       invokeRestart <- base::invokeRestart
[17:28:21.911]                       is.null <- base::is.null
[17:28:21.911]                       muffled <- FALSE
[17:28:21.911]                       if (inherits(cond, "message")) {
[17:28:21.911]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.911]                         if (muffled) 
[17:28:21.911]                           invokeRestart("muffleMessage")
[17:28:21.911]                       }
[17:28:21.911]                       else if (inherits(cond, "warning")) {
[17:28:21.911]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.911]                         if (muffled) 
[17:28:21.911]                           invokeRestart("muffleWarning")
[17:28:21.911]                       }
[17:28:21.911]                       else if (inherits(cond, "condition")) {
[17:28:21.911]                         if (!is.null(pattern)) {
[17:28:21.911]                           computeRestarts <- base::computeRestarts
[17:28:21.911]                           grepl <- base::grepl
[17:28:21.911]                           restarts <- computeRestarts(cond)
[17:28:21.911]                           for (restart in restarts) {
[17:28:21.911]                             name <- restart$name
[17:28:21.911]                             if (is.null(name)) 
[17:28:21.911]                               next
[17:28:21.911]                             if (!grepl(pattern, name)) 
[17:28:21.911]                               next
[17:28:21.911]                             invokeRestart(restart)
[17:28:21.911]                             muffled <- TRUE
[17:28:21.911]                             break
[17:28:21.911]                           }
[17:28:21.911]                         }
[17:28:21.911]                       }
[17:28:21.911]                       invisible(muffled)
[17:28:21.911]                     }
[17:28:21.911]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.911]                   }
[17:28:21.911]                 }
[17:28:21.911]                 else {
[17:28:21.911]                   if (TRUE) {
[17:28:21.911]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.911]                     {
[17:28:21.911]                       inherits <- base::inherits
[17:28:21.911]                       invokeRestart <- base::invokeRestart
[17:28:21.911]                       is.null <- base::is.null
[17:28:21.911]                       muffled <- FALSE
[17:28:21.911]                       if (inherits(cond, "message")) {
[17:28:21.911]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.911]                         if (muffled) 
[17:28:21.911]                           invokeRestart("muffleMessage")
[17:28:21.911]                       }
[17:28:21.911]                       else if (inherits(cond, "warning")) {
[17:28:21.911]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.911]                         if (muffled) 
[17:28:21.911]                           invokeRestart("muffleWarning")
[17:28:21.911]                       }
[17:28:21.911]                       else if (inherits(cond, "condition")) {
[17:28:21.911]                         if (!is.null(pattern)) {
[17:28:21.911]                           computeRestarts <- base::computeRestarts
[17:28:21.911]                           grepl <- base::grepl
[17:28:21.911]                           restarts <- computeRestarts(cond)
[17:28:21.911]                           for (restart in restarts) {
[17:28:21.911]                             name <- restart$name
[17:28:21.911]                             if (is.null(name)) 
[17:28:21.911]                               next
[17:28:21.911]                             if (!grepl(pattern, name)) 
[17:28:21.911]                               next
[17:28:21.911]                             invokeRestart(restart)
[17:28:21.911]                             muffled <- TRUE
[17:28:21.911]                             break
[17:28:21.911]                           }
[17:28:21.911]                         }
[17:28:21.911]                       }
[17:28:21.911]                       invisible(muffled)
[17:28:21.911]                     }
[17:28:21.911]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.911]                   }
[17:28:21.911]                 }
[17:28:21.911]             }
[17:28:21.911]         }))
[17:28:21.911]     }, error = function(ex) {
[17:28:21.911]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.911]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.911]                 ...future.rng), started = ...future.startTime, 
[17:28:21.911]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.911]             version = "1.8"), class = "FutureResult")
[17:28:21.911]     }, finally = {
[17:28:21.911]         if (!identical(...future.workdir, getwd())) 
[17:28:21.911]             setwd(...future.workdir)
[17:28:21.911]         {
[17:28:21.911]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.911]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.911]             }
[17:28:21.911]             base::options(...future.oldOptions)
[17:28:21.911]             if (.Platform$OS.type == "windows") {
[17:28:21.911]                 old_names <- names(...future.oldEnvVars)
[17:28:21.911]                 envs <- base::Sys.getenv()
[17:28:21.911]                 names <- names(envs)
[17:28:21.911]                 common <- intersect(names, old_names)
[17:28:21.911]                 added <- setdiff(names, old_names)
[17:28:21.911]                 removed <- setdiff(old_names, names)
[17:28:21.911]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.911]                   envs[common]]
[17:28:21.911]                 NAMES <- toupper(changed)
[17:28:21.911]                 args <- list()
[17:28:21.911]                 for (kk in seq_along(NAMES)) {
[17:28:21.911]                   name <- changed[[kk]]
[17:28:21.911]                   NAME <- NAMES[[kk]]
[17:28:21.911]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.911]                     next
[17:28:21.911]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.911]                 }
[17:28:21.911]                 NAMES <- toupper(added)
[17:28:21.911]                 for (kk in seq_along(NAMES)) {
[17:28:21.911]                   name <- added[[kk]]
[17:28:21.911]                   NAME <- NAMES[[kk]]
[17:28:21.911]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.911]                     next
[17:28:21.911]                   args[[name]] <- ""
[17:28:21.911]                 }
[17:28:21.911]                 NAMES <- toupper(removed)
[17:28:21.911]                 for (kk in seq_along(NAMES)) {
[17:28:21.911]                   name <- removed[[kk]]
[17:28:21.911]                   NAME <- NAMES[[kk]]
[17:28:21.911]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.911]                     next
[17:28:21.911]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.911]                 }
[17:28:21.911]                 if (length(args) > 0) 
[17:28:21.911]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.911]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.911]             }
[17:28:21.911]             else {
[17:28:21.911]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.911]             }
[17:28:21.911]             {
[17:28:21.911]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.911]                   0L) {
[17:28:21.911]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.911]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.911]                   base::options(opts)
[17:28:21.911]                 }
[17:28:21.911]                 {
[17:28:21.911]                   {
[17:28:21.911]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.911]                     NULL
[17:28:21.911]                   }
[17:28:21.911]                   options(future.plan = NULL)
[17:28:21.911]                   if (is.na(NA_character_)) 
[17:28:21.911]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.911]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.911]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.911]                     .init = FALSE)
[17:28:21.911]                 }
[17:28:21.911]             }
[17:28:21.911]         }
[17:28:21.911]     })
[17:28:21.911]     if (TRUE) {
[17:28:21.911]         base::sink(type = "output", split = FALSE)
[17:28:21.911]         if (TRUE) {
[17:28:21.911]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.911]         }
[17:28:21.911]         else {
[17:28:21.911]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.911]         }
[17:28:21.911]         base::close(...future.stdout)
[17:28:21.911]         ...future.stdout <- NULL
[17:28:21.911]     }
[17:28:21.911]     ...future.result$conditions <- ...future.conditions
[17:28:21.911]     ...future.result$finished <- base::Sys.time()
[17:28:21.911]     ...future.result
[17:28:21.911] }
[17:28:21.916] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:21.917] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:21.917] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:21.917] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:21.918] MultisessionFuture started
[17:28:21.918] - Launch lazy future ... done
[17:28:21.918] run() for 'MultisessionFuture' ... done
[17:28:21.919] getGlobalsAndPackages() ...
[17:28:21.919] Searching for globals...
[17:28:21.920] - globals found: [3] '{', 'sample', 'x'
[17:28:21.920] Searching for globals ... DONE
[17:28:21.920] Resolving globals: FALSE
[17:28:21.921] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.921] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.922] - globals: [1] 'x'
[17:28:21.922] 
[17:28:21.922] getGlobalsAndPackages() ... DONE
[17:28:21.922] run() for 'Future' ...
[17:28:21.922] - state: 'created'
[17:28:21.923] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.936] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.936] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.936]   - Field: 'node'
[17:28:21.937]   - Field: 'label'
[17:28:21.937]   - Field: 'local'
[17:28:21.937]   - Field: 'owner'
[17:28:21.937]   - Field: 'envir'
[17:28:21.937]   - Field: 'workers'
[17:28:21.937]   - Field: 'packages'
[17:28:21.938]   - Field: 'gc'
[17:28:21.938]   - Field: 'conditions'
[17:28:21.938]   - Field: 'persistent'
[17:28:21.938]   - Field: 'expr'
[17:28:21.938]   - Field: 'uuid'
[17:28:21.939]   - Field: 'seed'
[17:28:21.939]   - Field: 'version'
[17:28:21.939]   - Field: 'result'
[17:28:21.939]   - Field: 'asynchronous'
[17:28:21.939]   - Field: 'calls'
[17:28:21.939]   - Field: 'globals'
[17:28:21.940]   - Field: 'stdout'
[17:28:21.940]   - Field: 'earlySignal'
[17:28:21.940]   - Field: 'lazy'
[17:28:21.940]   - Field: 'state'
[17:28:21.940] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.940] - Launch lazy future ...
[17:28:21.941] Packages needed by the future expression (n = 0): <none>
[17:28:21.941] Packages needed by future strategies (n = 0): <none>
[17:28:21.941] {
[17:28:21.941]     {
[17:28:21.941]         {
[17:28:21.941]             ...future.startTime <- base::Sys.time()
[17:28:21.941]             {
[17:28:21.941]                 {
[17:28:21.941]                   {
[17:28:21.941]                     {
[17:28:21.941]                       base::local({
[17:28:21.941]                         has_future <- base::requireNamespace("future", 
[17:28:21.941]                           quietly = TRUE)
[17:28:21.941]                         if (has_future) {
[17:28:21.941]                           ns <- base::getNamespace("future")
[17:28:21.941]                           version <- ns[[".package"]][["version"]]
[17:28:21.941]                           if (is.null(version)) 
[17:28:21.941]                             version <- utils::packageVersion("future")
[17:28:21.941]                         }
[17:28:21.941]                         else {
[17:28:21.941]                           version <- NULL
[17:28:21.941]                         }
[17:28:21.941]                         if (!has_future || version < "1.8.0") {
[17:28:21.941]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.941]                             "", base::R.version$version.string), 
[17:28:21.941]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:21.941]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:21.941]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.941]                               "release", "version")], collapse = " "), 
[17:28:21.941]                             hostname = base::Sys.info()[["nodename"]])
[17:28:21.941]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.941]                             info)
[17:28:21.941]                           info <- base::paste(info, collapse = "; ")
[17:28:21.941]                           if (!has_future) {
[17:28:21.941]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.941]                               info)
[17:28:21.941]                           }
[17:28:21.941]                           else {
[17:28:21.941]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.941]                               info, version)
[17:28:21.941]                           }
[17:28:21.941]                           base::stop(msg)
[17:28:21.941]                         }
[17:28:21.941]                       })
[17:28:21.941]                     }
[17:28:21.941]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.941]                     base::options(mc.cores = 1L)
[17:28:21.941]                   }
[17:28:21.941]                   ...future.strategy.old <- future::plan("list")
[17:28:21.941]                   options(future.plan = NULL)
[17:28:21.941]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.941]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:21.941]                 }
[17:28:21.941]                 ...future.workdir <- getwd()
[17:28:21.941]             }
[17:28:21.941]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.941]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.941]         }
[17:28:21.941]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.941]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.941]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.941]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.941]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.941]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.941]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.941]             base::names(...future.oldOptions))
[17:28:21.941]     }
[17:28:21.941]     if (FALSE) {
[17:28:21.941]     }
[17:28:21.941]     else {
[17:28:21.941]         if (TRUE) {
[17:28:21.941]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.941]                 open = "w")
[17:28:21.941]         }
[17:28:21.941]         else {
[17:28:21.941]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.941]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.941]         }
[17:28:21.941]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.941]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.941]             base::sink(type = "output", split = FALSE)
[17:28:21.941]             base::close(...future.stdout)
[17:28:21.941]         }, add = TRUE)
[17:28:21.941]     }
[17:28:21.941]     ...future.frame <- base::sys.nframe()
[17:28:21.941]     ...future.conditions <- base::list()
[17:28:21.941]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.941]     if (FALSE) {
[17:28:21.941]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.941]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.941]     }
[17:28:21.941]     ...future.result <- base::tryCatch({
[17:28:21.941]         base::withCallingHandlers({
[17:28:21.941]             ...future.value <- base::withVisible(base::local({
[17:28:21.941]                 ...future.makeSendCondition <- base::local({
[17:28:21.941]                   sendCondition <- NULL
[17:28:21.941]                   function(frame = 1L) {
[17:28:21.941]                     if (is.function(sendCondition)) 
[17:28:21.941]                       return(sendCondition)
[17:28:21.941]                     ns <- getNamespace("parallel")
[17:28:21.941]                     if (exists("sendData", mode = "function", 
[17:28:21.941]                       envir = ns)) {
[17:28:21.941]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.941]                         envir = ns)
[17:28:21.941]                       envir <- sys.frame(frame)
[17:28:21.941]                       master <- NULL
[17:28:21.941]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.941]                         !identical(envir, emptyenv())) {
[17:28:21.941]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.941]                           inherits = FALSE)) {
[17:28:21.941]                           master <- get("master", mode = "list", 
[17:28:21.941]                             envir = envir, inherits = FALSE)
[17:28:21.941]                           if (inherits(master, c("SOCKnode", 
[17:28:21.941]                             "SOCK0node"))) {
[17:28:21.941]                             sendCondition <<- function(cond) {
[17:28:21.941]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.941]                                 success = TRUE)
[17:28:21.941]                               parallel_sendData(master, data)
[17:28:21.941]                             }
[17:28:21.941]                             return(sendCondition)
[17:28:21.941]                           }
[17:28:21.941]                         }
[17:28:21.941]                         frame <- frame + 1L
[17:28:21.941]                         envir <- sys.frame(frame)
[17:28:21.941]                       }
[17:28:21.941]                     }
[17:28:21.941]                     sendCondition <<- function(cond) NULL
[17:28:21.941]                   }
[17:28:21.941]                 })
[17:28:21.941]                 withCallingHandlers({
[17:28:21.941]                   {
[17:28:21.941]                     sample(x, size = 1L)
[17:28:21.941]                   }
[17:28:21.941]                 }, immediateCondition = function(cond) {
[17:28:21.941]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.941]                   sendCondition(cond)
[17:28:21.941]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.941]                   {
[17:28:21.941]                     inherits <- base::inherits
[17:28:21.941]                     invokeRestart <- base::invokeRestart
[17:28:21.941]                     is.null <- base::is.null
[17:28:21.941]                     muffled <- FALSE
[17:28:21.941]                     if (inherits(cond, "message")) {
[17:28:21.941]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.941]                       if (muffled) 
[17:28:21.941]                         invokeRestart("muffleMessage")
[17:28:21.941]                     }
[17:28:21.941]                     else if (inherits(cond, "warning")) {
[17:28:21.941]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.941]                       if (muffled) 
[17:28:21.941]                         invokeRestart("muffleWarning")
[17:28:21.941]                     }
[17:28:21.941]                     else if (inherits(cond, "condition")) {
[17:28:21.941]                       if (!is.null(pattern)) {
[17:28:21.941]                         computeRestarts <- base::computeRestarts
[17:28:21.941]                         grepl <- base::grepl
[17:28:21.941]                         restarts <- computeRestarts(cond)
[17:28:21.941]                         for (restart in restarts) {
[17:28:21.941]                           name <- restart$name
[17:28:21.941]                           if (is.null(name)) 
[17:28:21.941]                             next
[17:28:21.941]                           if (!grepl(pattern, name)) 
[17:28:21.941]                             next
[17:28:21.941]                           invokeRestart(restart)
[17:28:21.941]                           muffled <- TRUE
[17:28:21.941]                           break
[17:28:21.941]                         }
[17:28:21.941]                       }
[17:28:21.941]                     }
[17:28:21.941]                     invisible(muffled)
[17:28:21.941]                   }
[17:28:21.941]                   muffleCondition(cond)
[17:28:21.941]                 })
[17:28:21.941]             }))
[17:28:21.941]             future::FutureResult(value = ...future.value$value, 
[17:28:21.941]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.941]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.941]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.941]                     ...future.globalenv.names))
[17:28:21.941]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.941]         }, condition = base::local({
[17:28:21.941]             c <- base::c
[17:28:21.941]             inherits <- base::inherits
[17:28:21.941]             invokeRestart <- base::invokeRestart
[17:28:21.941]             length <- base::length
[17:28:21.941]             list <- base::list
[17:28:21.941]             seq.int <- base::seq.int
[17:28:21.941]             signalCondition <- base::signalCondition
[17:28:21.941]             sys.calls <- base::sys.calls
[17:28:21.941]             `[[` <- base::`[[`
[17:28:21.941]             `+` <- base::`+`
[17:28:21.941]             `<<-` <- base::`<<-`
[17:28:21.941]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.941]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.941]                   3L)]
[17:28:21.941]             }
[17:28:21.941]             function(cond) {
[17:28:21.941]                 is_error <- inherits(cond, "error")
[17:28:21.941]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.941]                   NULL)
[17:28:21.941]                 if (is_error) {
[17:28:21.941]                   sessionInformation <- function() {
[17:28:21.941]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.941]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.941]                       search = base::search(), system = base::Sys.info())
[17:28:21.941]                   }
[17:28:21.941]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.941]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.941]                     cond$call), session = sessionInformation(), 
[17:28:21.941]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.941]                   signalCondition(cond)
[17:28:21.941]                 }
[17:28:21.941]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.941]                 "immediateCondition"))) {
[17:28:21.941]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.941]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.941]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.941]                   if (TRUE && !signal) {
[17:28:21.941]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.941]                     {
[17:28:21.941]                       inherits <- base::inherits
[17:28:21.941]                       invokeRestart <- base::invokeRestart
[17:28:21.941]                       is.null <- base::is.null
[17:28:21.941]                       muffled <- FALSE
[17:28:21.941]                       if (inherits(cond, "message")) {
[17:28:21.941]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.941]                         if (muffled) 
[17:28:21.941]                           invokeRestart("muffleMessage")
[17:28:21.941]                       }
[17:28:21.941]                       else if (inherits(cond, "warning")) {
[17:28:21.941]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.941]                         if (muffled) 
[17:28:21.941]                           invokeRestart("muffleWarning")
[17:28:21.941]                       }
[17:28:21.941]                       else if (inherits(cond, "condition")) {
[17:28:21.941]                         if (!is.null(pattern)) {
[17:28:21.941]                           computeRestarts <- base::computeRestarts
[17:28:21.941]                           grepl <- base::grepl
[17:28:21.941]                           restarts <- computeRestarts(cond)
[17:28:21.941]                           for (restart in restarts) {
[17:28:21.941]                             name <- restart$name
[17:28:21.941]                             if (is.null(name)) 
[17:28:21.941]                               next
[17:28:21.941]                             if (!grepl(pattern, name)) 
[17:28:21.941]                               next
[17:28:21.941]                             invokeRestart(restart)
[17:28:21.941]                             muffled <- TRUE
[17:28:21.941]                             break
[17:28:21.941]                           }
[17:28:21.941]                         }
[17:28:21.941]                       }
[17:28:21.941]                       invisible(muffled)
[17:28:21.941]                     }
[17:28:21.941]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.941]                   }
[17:28:21.941]                 }
[17:28:21.941]                 else {
[17:28:21.941]                   if (TRUE) {
[17:28:21.941]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.941]                     {
[17:28:21.941]                       inherits <- base::inherits
[17:28:21.941]                       invokeRestart <- base::invokeRestart
[17:28:21.941]                       is.null <- base::is.null
[17:28:21.941]                       muffled <- FALSE
[17:28:21.941]                       if (inherits(cond, "message")) {
[17:28:21.941]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.941]                         if (muffled) 
[17:28:21.941]                           invokeRestart("muffleMessage")
[17:28:21.941]                       }
[17:28:21.941]                       else if (inherits(cond, "warning")) {
[17:28:21.941]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.941]                         if (muffled) 
[17:28:21.941]                           invokeRestart("muffleWarning")
[17:28:21.941]                       }
[17:28:21.941]                       else if (inherits(cond, "condition")) {
[17:28:21.941]                         if (!is.null(pattern)) {
[17:28:21.941]                           computeRestarts <- base::computeRestarts
[17:28:21.941]                           grepl <- base::grepl
[17:28:21.941]                           restarts <- computeRestarts(cond)
[17:28:21.941]                           for (restart in restarts) {
[17:28:21.941]                             name <- restart$name
[17:28:21.941]                             if (is.null(name)) 
[17:28:21.941]                               next
[17:28:21.941]                             if (!grepl(pattern, name)) 
[17:28:21.941]                               next
[17:28:21.941]                             invokeRestart(restart)
[17:28:21.941]                             muffled <- TRUE
[17:28:21.941]                             break
[17:28:21.941]                           }
[17:28:21.941]                         }
[17:28:21.941]                       }
[17:28:21.941]                       invisible(muffled)
[17:28:21.941]                     }
[17:28:21.941]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.941]                   }
[17:28:21.941]                 }
[17:28:21.941]             }
[17:28:21.941]         }))
[17:28:21.941]     }, error = function(ex) {
[17:28:21.941]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.941]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.941]                 ...future.rng), started = ...future.startTime, 
[17:28:21.941]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.941]             version = "1.8"), class = "FutureResult")
[17:28:21.941]     }, finally = {
[17:28:21.941]         if (!identical(...future.workdir, getwd())) 
[17:28:21.941]             setwd(...future.workdir)
[17:28:21.941]         {
[17:28:21.941]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.941]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.941]             }
[17:28:21.941]             base::options(...future.oldOptions)
[17:28:21.941]             if (.Platform$OS.type == "windows") {
[17:28:21.941]                 old_names <- names(...future.oldEnvVars)
[17:28:21.941]                 envs <- base::Sys.getenv()
[17:28:21.941]                 names <- names(envs)
[17:28:21.941]                 common <- intersect(names, old_names)
[17:28:21.941]                 added <- setdiff(names, old_names)
[17:28:21.941]                 removed <- setdiff(old_names, names)
[17:28:21.941]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.941]                   envs[common]]
[17:28:21.941]                 NAMES <- toupper(changed)
[17:28:21.941]                 args <- list()
[17:28:21.941]                 for (kk in seq_along(NAMES)) {
[17:28:21.941]                   name <- changed[[kk]]
[17:28:21.941]                   NAME <- NAMES[[kk]]
[17:28:21.941]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.941]                     next
[17:28:21.941]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.941]                 }
[17:28:21.941]                 NAMES <- toupper(added)
[17:28:21.941]                 for (kk in seq_along(NAMES)) {
[17:28:21.941]                   name <- added[[kk]]
[17:28:21.941]                   NAME <- NAMES[[kk]]
[17:28:21.941]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.941]                     next
[17:28:21.941]                   args[[name]] <- ""
[17:28:21.941]                 }
[17:28:21.941]                 NAMES <- toupper(removed)
[17:28:21.941]                 for (kk in seq_along(NAMES)) {
[17:28:21.941]                   name <- removed[[kk]]
[17:28:21.941]                   NAME <- NAMES[[kk]]
[17:28:21.941]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.941]                     next
[17:28:21.941]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.941]                 }
[17:28:21.941]                 if (length(args) > 0) 
[17:28:21.941]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.941]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.941]             }
[17:28:21.941]             else {
[17:28:21.941]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.941]             }
[17:28:21.941]             {
[17:28:21.941]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.941]                   0L) {
[17:28:21.941]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.941]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.941]                   base::options(opts)
[17:28:21.941]                 }
[17:28:21.941]                 {
[17:28:21.941]                   {
[17:28:21.941]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.941]                     NULL
[17:28:21.941]                   }
[17:28:21.941]                   options(future.plan = NULL)
[17:28:21.941]                   if (is.na(NA_character_)) 
[17:28:21.941]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.941]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.941]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.941]                     .init = FALSE)
[17:28:21.941]                 }
[17:28:21.941]             }
[17:28:21.941]         }
[17:28:21.941]     })
[17:28:21.941]     if (TRUE) {
[17:28:21.941]         base::sink(type = "output", split = FALSE)
[17:28:21.941]         if (TRUE) {
[17:28:21.941]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.941]         }
[17:28:21.941]         else {
[17:28:21.941]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.941]         }
[17:28:21.941]         base::close(...future.stdout)
[17:28:21.941]         ...future.stdout <- NULL
[17:28:21.941]     }
[17:28:21.941]     ...future.result$conditions <- ...future.conditions
[17:28:21.941]     ...future.result$finished <- base::Sys.time()
[17:28:21.941]     ...future.result
[17:28:21.941] }
[17:28:21.946] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:21.961] receiveMessageFromWorker() for ClusterFuture ...
[17:28:21.961] - Validating connection of MultisessionFuture
[17:28:21.961] - received message: FutureResult
[17:28:21.961] - Received FutureResult
[17:28:21.961] - Erased future from FutureRegistry
[17:28:21.962] result() for ClusterFuture ...
[17:28:21.962] - result already collected: FutureResult
[17:28:21.962] result() for ClusterFuture ... done
[17:28:21.962] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:21.962] result() for ClusterFuture ...
[17:28:21.963] - result already collected: FutureResult
[17:28:21.963] result() for ClusterFuture ... done
[17:28:21.963] result() for ClusterFuture ...
[17:28:21.963] - result already collected: FutureResult
[17:28:21.963] result() for ClusterFuture ... done
[17:28:21.964] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:21.964] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:21.965] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:21.965] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:21.966] MultisessionFuture started
[17:28:21.966] - Launch lazy future ... done
[17:28:21.966] run() for 'MultisessionFuture' ... done
[17:28:21.966] getGlobalsAndPackages() ...
[17:28:21.967] Searching for globals...
[17:28:21.968] - globals found: [3] '{', 'sample', 'x'
[17:28:21.968] Searching for globals ... DONE
[17:28:21.968] Resolving globals: FALSE
[17:28:21.969] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:21.969] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:21.969] - globals: [1] 'x'
[17:28:21.969] 
[17:28:21.970] getGlobalsAndPackages() ... DONE
[17:28:21.970] run() for 'Future' ...
[17:28:21.970] - state: 'created'
[17:28:21.970] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:21.984] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:21.984] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:21.984]   - Field: 'node'
[17:28:21.984]   - Field: 'label'
[17:28:21.985]   - Field: 'local'
[17:28:21.985]   - Field: 'owner'
[17:28:21.985]   - Field: 'envir'
[17:28:21.985]   - Field: 'workers'
[17:28:21.985]   - Field: 'packages'
[17:28:21.986]   - Field: 'gc'
[17:28:21.986]   - Field: 'conditions'
[17:28:21.986]   - Field: 'persistent'
[17:28:21.986]   - Field: 'expr'
[17:28:21.986]   - Field: 'uuid'
[17:28:21.986]   - Field: 'seed'
[17:28:21.987]   - Field: 'version'
[17:28:21.987]   - Field: 'result'
[17:28:21.987]   - Field: 'asynchronous'
[17:28:21.987]   - Field: 'calls'
[17:28:21.990]   - Field: 'globals'
[17:28:21.990]   - Field: 'stdout'
[17:28:21.990]   - Field: 'earlySignal'
[17:28:21.990]   - Field: 'lazy'
[17:28:21.991]   - Field: 'state'
[17:28:21.991] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:21.991] - Launch lazy future ...
[17:28:21.991] Packages needed by the future expression (n = 0): <none>
[17:28:21.991] Packages needed by future strategies (n = 0): <none>
[17:28:21.992] {
[17:28:21.992]     {
[17:28:21.992]         {
[17:28:21.992]             ...future.startTime <- base::Sys.time()
[17:28:21.992]             {
[17:28:21.992]                 {
[17:28:21.992]                   {
[17:28:21.992]                     {
[17:28:21.992]                       base::local({
[17:28:21.992]                         has_future <- base::requireNamespace("future", 
[17:28:21.992]                           quietly = TRUE)
[17:28:21.992]                         if (has_future) {
[17:28:21.992]                           ns <- base::getNamespace("future")
[17:28:21.992]                           version <- ns[[".package"]][["version"]]
[17:28:21.992]                           if (is.null(version)) 
[17:28:21.992]                             version <- utils::packageVersion("future")
[17:28:21.992]                         }
[17:28:21.992]                         else {
[17:28:21.992]                           version <- NULL
[17:28:21.992]                         }
[17:28:21.992]                         if (!has_future || version < "1.8.0") {
[17:28:21.992]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:21.992]                             "", base::R.version$version.string), 
[17:28:21.992]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:21.992]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:21.992]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:21.992]                               "release", "version")], collapse = " "), 
[17:28:21.992]                             hostname = base::Sys.info()[["nodename"]])
[17:28:21.992]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:21.992]                             info)
[17:28:21.992]                           info <- base::paste(info, collapse = "; ")
[17:28:21.992]                           if (!has_future) {
[17:28:21.992]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:21.992]                               info)
[17:28:21.992]                           }
[17:28:21.992]                           else {
[17:28:21.992]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:21.992]                               info, version)
[17:28:21.992]                           }
[17:28:21.992]                           base::stop(msg)
[17:28:21.992]                         }
[17:28:21.992]                       })
[17:28:21.992]                     }
[17:28:21.992]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:21.992]                     base::options(mc.cores = 1L)
[17:28:21.992]                   }
[17:28:21.992]                   ...future.strategy.old <- future::plan("list")
[17:28:21.992]                   options(future.plan = NULL)
[17:28:21.992]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.992]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:21.992]                 }
[17:28:21.992]                 ...future.workdir <- getwd()
[17:28:21.992]             }
[17:28:21.992]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:21.992]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:21.992]         }
[17:28:21.992]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:21.992]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:21.992]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:21.992]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:21.992]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:21.992]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:21.992]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:21.992]             base::names(...future.oldOptions))
[17:28:21.992]     }
[17:28:21.992]     if (FALSE) {
[17:28:21.992]     }
[17:28:21.992]     else {
[17:28:21.992]         if (TRUE) {
[17:28:21.992]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:21.992]                 open = "w")
[17:28:21.992]         }
[17:28:21.992]         else {
[17:28:21.992]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:21.992]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:21.992]         }
[17:28:21.992]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:21.992]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:21.992]             base::sink(type = "output", split = FALSE)
[17:28:21.992]             base::close(...future.stdout)
[17:28:21.992]         }, add = TRUE)
[17:28:21.992]     }
[17:28:21.992]     ...future.frame <- base::sys.nframe()
[17:28:21.992]     ...future.conditions <- base::list()
[17:28:21.992]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:21.992]     if (FALSE) {
[17:28:21.992]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:21.992]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:21.992]     }
[17:28:21.992]     ...future.result <- base::tryCatch({
[17:28:21.992]         base::withCallingHandlers({
[17:28:21.992]             ...future.value <- base::withVisible(base::local({
[17:28:21.992]                 ...future.makeSendCondition <- base::local({
[17:28:21.992]                   sendCondition <- NULL
[17:28:21.992]                   function(frame = 1L) {
[17:28:21.992]                     if (is.function(sendCondition)) 
[17:28:21.992]                       return(sendCondition)
[17:28:21.992]                     ns <- getNamespace("parallel")
[17:28:21.992]                     if (exists("sendData", mode = "function", 
[17:28:21.992]                       envir = ns)) {
[17:28:21.992]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:21.992]                         envir = ns)
[17:28:21.992]                       envir <- sys.frame(frame)
[17:28:21.992]                       master <- NULL
[17:28:21.992]                       while (!identical(envir, .GlobalEnv) && 
[17:28:21.992]                         !identical(envir, emptyenv())) {
[17:28:21.992]                         if (exists("master", mode = "list", envir = envir, 
[17:28:21.992]                           inherits = FALSE)) {
[17:28:21.992]                           master <- get("master", mode = "list", 
[17:28:21.992]                             envir = envir, inherits = FALSE)
[17:28:21.992]                           if (inherits(master, c("SOCKnode", 
[17:28:21.992]                             "SOCK0node"))) {
[17:28:21.992]                             sendCondition <<- function(cond) {
[17:28:21.992]                               data <- list(type = "VALUE", value = cond, 
[17:28:21.992]                                 success = TRUE)
[17:28:21.992]                               parallel_sendData(master, data)
[17:28:21.992]                             }
[17:28:21.992]                             return(sendCondition)
[17:28:21.992]                           }
[17:28:21.992]                         }
[17:28:21.992]                         frame <- frame + 1L
[17:28:21.992]                         envir <- sys.frame(frame)
[17:28:21.992]                       }
[17:28:21.992]                     }
[17:28:21.992]                     sendCondition <<- function(cond) NULL
[17:28:21.992]                   }
[17:28:21.992]                 })
[17:28:21.992]                 withCallingHandlers({
[17:28:21.992]                   {
[17:28:21.992]                     sample(x, size = 1L)
[17:28:21.992]                   }
[17:28:21.992]                 }, immediateCondition = function(cond) {
[17:28:21.992]                   sendCondition <- ...future.makeSendCondition()
[17:28:21.992]                   sendCondition(cond)
[17:28:21.992]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.992]                   {
[17:28:21.992]                     inherits <- base::inherits
[17:28:21.992]                     invokeRestart <- base::invokeRestart
[17:28:21.992]                     is.null <- base::is.null
[17:28:21.992]                     muffled <- FALSE
[17:28:21.992]                     if (inherits(cond, "message")) {
[17:28:21.992]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:21.992]                       if (muffled) 
[17:28:21.992]                         invokeRestart("muffleMessage")
[17:28:21.992]                     }
[17:28:21.992]                     else if (inherits(cond, "warning")) {
[17:28:21.992]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:21.992]                       if (muffled) 
[17:28:21.992]                         invokeRestart("muffleWarning")
[17:28:21.992]                     }
[17:28:21.992]                     else if (inherits(cond, "condition")) {
[17:28:21.992]                       if (!is.null(pattern)) {
[17:28:21.992]                         computeRestarts <- base::computeRestarts
[17:28:21.992]                         grepl <- base::grepl
[17:28:21.992]                         restarts <- computeRestarts(cond)
[17:28:21.992]                         for (restart in restarts) {
[17:28:21.992]                           name <- restart$name
[17:28:21.992]                           if (is.null(name)) 
[17:28:21.992]                             next
[17:28:21.992]                           if (!grepl(pattern, name)) 
[17:28:21.992]                             next
[17:28:21.992]                           invokeRestart(restart)
[17:28:21.992]                           muffled <- TRUE
[17:28:21.992]                           break
[17:28:21.992]                         }
[17:28:21.992]                       }
[17:28:21.992]                     }
[17:28:21.992]                     invisible(muffled)
[17:28:21.992]                   }
[17:28:21.992]                   muffleCondition(cond)
[17:28:21.992]                 })
[17:28:21.992]             }))
[17:28:21.992]             future::FutureResult(value = ...future.value$value, 
[17:28:21.992]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.992]                   ...future.rng), globalenv = if (FALSE) 
[17:28:21.992]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:21.992]                     ...future.globalenv.names))
[17:28:21.992]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:21.992]         }, condition = base::local({
[17:28:21.992]             c <- base::c
[17:28:21.992]             inherits <- base::inherits
[17:28:21.992]             invokeRestart <- base::invokeRestart
[17:28:21.992]             length <- base::length
[17:28:21.992]             list <- base::list
[17:28:21.992]             seq.int <- base::seq.int
[17:28:21.992]             signalCondition <- base::signalCondition
[17:28:21.992]             sys.calls <- base::sys.calls
[17:28:21.992]             `[[` <- base::`[[`
[17:28:21.992]             `+` <- base::`+`
[17:28:21.992]             `<<-` <- base::`<<-`
[17:28:21.992]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:21.992]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:21.992]                   3L)]
[17:28:21.992]             }
[17:28:21.992]             function(cond) {
[17:28:21.992]                 is_error <- inherits(cond, "error")
[17:28:21.992]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:21.992]                   NULL)
[17:28:21.992]                 if (is_error) {
[17:28:21.992]                   sessionInformation <- function() {
[17:28:21.992]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:21.992]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:21.992]                       search = base::search(), system = base::Sys.info())
[17:28:21.992]                   }
[17:28:21.992]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.992]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:21.992]                     cond$call), session = sessionInformation(), 
[17:28:21.992]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:21.992]                   signalCondition(cond)
[17:28:21.992]                 }
[17:28:21.992]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:21.992]                 "immediateCondition"))) {
[17:28:21.992]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:21.992]                   ...future.conditions[[length(...future.conditions) + 
[17:28:21.992]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:21.992]                   if (TRUE && !signal) {
[17:28:21.992]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.992]                     {
[17:28:21.992]                       inherits <- base::inherits
[17:28:21.992]                       invokeRestart <- base::invokeRestart
[17:28:21.992]                       is.null <- base::is.null
[17:28:21.992]                       muffled <- FALSE
[17:28:21.992]                       if (inherits(cond, "message")) {
[17:28:21.992]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.992]                         if (muffled) 
[17:28:21.992]                           invokeRestart("muffleMessage")
[17:28:21.992]                       }
[17:28:21.992]                       else if (inherits(cond, "warning")) {
[17:28:21.992]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.992]                         if (muffled) 
[17:28:21.992]                           invokeRestart("muffleWarning")
[17:28:21.992]                       }
[17:28:21.992]                       else if (inherits(cond, "condition")) {
[17:28:21.992]                         if (!is.null(pattern)) {
[17:28:21.992]                           computeRestarts <- base::computeRestarts
[17:28:21.992]                           grepl <- base::grepl
[17:28:21.992]                           restarts <- computeRestarts(cond)
[17:28:21.992]                           for (restart in restarts) {
[17:28:21.992]                             name <- restart$name
[17:28:21.992]                             if (is.null(name)) 
[17:28:21.992]                               next
[17:28:21.992]                             if (!grepl(pattern, name)) 
[17:28:21.992]                               next
[17:28:21.992]                             invokeRestart(restart)
[17:28:21.992]                             muffled <- TRUE
[17:28:21.992]                             break
[17:28:21.992]                           }
[17:28:21.992]                         }
[17:28:21.992]                       }
[17:28:21.992]                       invisible(muffled)
[17:28:21.992]                     }
[17:28:21.992]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.992]                   }
[17:28:21.992]                 }
[17:28:21.992]                 else {
[17:28:21.992]                   if (TRUE) {
[17:28:21.992]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:21.992]                     {
[17:28:21.992]                       inherits <- base::inherits
[17:28:21.992]                       invokeRestart <- base::invokeRestart
[17:28:21.992]                       is.null <- base::is.null
[17:28:21.992]                       muffled <- FALSE
[17:28:21.992]                       if (inherits(cond, "message")) {
[17:28:21.992]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:21.992]                         if (muffled) 
[17:28:21.992]                           invokeRestart("muffleMessage")
[17:28:21.992]                       }
[17:28:21.992]                       else if (inherits(cond, "warning")) {
[17:28:21.992]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:21.992]                         if (muffled) 
[17:28:21.992]                           invokeRestart("muffleWarning")
[17:28:21.992]                       }
[17:28:21.992]                       else if (inherits(cond, "condition")) {
[17:28:21.992]                         if (!is.null(pattern)) {
[17:28:21.992]                           computeRestarts <- base::computeRestarts
[17:28:21.992]                           grepl <- base::grepl
[17:28:21.992]                           restarts <- computeRestarts(cond)
[17:28:21.992]                           for (restart in restarts) {
[17:28:21.992]                             name <- restart$name
[17:28:21.992]                             if (is.null(name)) 
[17:28:21.992]                               next
[17:28:21.992]                             if (!grepl(pattern, name)) 
[17:28:21.992]                               next
[17:28:21.992]                             invokeRestart(restart)
[17:28:21.992]                             muffled <- TRUE
[17:28:21.992]                             break
[17:28:21.992]                           }
[17:28:21.992]                         }
[17:28:21.992]                       }
[17:28:21.992]                       invisible(muffled)
[17:28:21.992]                     }
[17:28:21.992]                     muffleCondition(cond, pattern = "^muffle")
[17:28:21.992]                   }
[17:28:21.992]                 }
[17:28:21.992]             }
[17:28:21.992]         }))
[17:28:21.992]     }, error = function(ex) {
[17:28:21.992]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:21.992]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:21.992]                 ...future.rng), started = ...future.startTime, 
[17:28:21.992]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:21.992]             version = "1.8"), class = "FutureResult")
[17:28:21.992]     }, finally = {
[17:28:21.992]         if (!identical(...future.workdir, getwd())) 
[17:28:21.992]             setwd(...future.workdir)
[17:28:21.992]         {
[17:28:21.992]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:21.992]                 ...future.oldOptions$nwarnings <- NULL
[17:28:21.992]             }
[17:28:21.992]             base::options(...future.oldOptions)
[17:28:21.992]             if (.Platform$OS.type == "windows") {
[17:28:21.992]                 old_names <- names(...future.oldEnvVars)
[17:28:21.992]                 envs <- base::Sys.getenv()
[17:28:21.992]                 names <- names(envs)
[17:28:21.992]                 common <- intersect(names, old_names)
[17:28:21.992]                 added <- setdiff(names, old_names)
[17:28:21.992]                 removed <- setdiff(old_names, names)
[17:28:21.992]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:21.992]                   envs[common]]
[17:28:21.992]                 NAMES <- toupper(changed)
[17:28:21.992]                 args <- list()
[17:28:21.992]                 for (kk in seq_along(NAMES)) {
[17:28:21.992]                   name <- changed[[kk]]
[17:28:21.992]                   NAME <- NAMES[[kk]]
[17:28:21.992]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.992]                     next
[17:28:21.992]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.992]                 }
[17:28:21.992]                 NAMES <- toupper(added)
[17:28:21.992]                 for (kk in seq_along(NAMES)) {
[17:28:21.992]                   name <- added[[kk]]
[17:28:21.992]                   NAME <- NAMES[[kk]]
[17:28:21.992]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.992]                     next
[17:28:21.992]                   args[[name]] <- ""
[17:28:21.992]                 }
[17:28:21.992]                 NAMES <- toupper(removed)
[17:28:21.992]                 for (kk in seq_along(NAMES)) {
[17:28:21.992]                   name <- removed[[kk]]
[17:28:21.992]                   NAME <- NAMES[[kk]]
[17:28:21.992]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:21.992]                     next
[17:28:21.992]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:21.992]                 }
[17:28:21.992]                 if (length(args) > 0) 
[17:28:21.992]                   base::do.call(base::Sys.setenv, args = args)
[17:28:21.992]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:21.992]             }
[17:28:21.992]             else {
[17:28:21.992]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:21.992]             }
[17:28:21.992]             {
[17:28:21.992]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:21.992]                   0L) {
[17:28:21.992]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:21.992]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:21.992]                   base::options(opts)
[17:28:21.992]                 }
[17:28:21.992]                 {
[17:28:21.992]                   {
[17:28:21.992]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:21.992]                     NULL
[17:28:21.992]                   }
[17:28:21.992]                   options(future.plan = NULL)
[17:28:21.992]                   if (is.na(NA_character_)) 
[17:28:21.992]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:21.992]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:21.992]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:21.992]                     .init = FALSE)
[17:28:21.992]                 }
[17:28:21.992]             }
[17:28:21.992]         }
[17:28:21.992]     })
[17:28:21.992]     if (TRUE) {
[17:28:21.992]         base::sink(type = "output", split = FALSE)
[17:28:21.992]         if (TRUE) {
[17:28:21.992]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:21.992]         }
[17:28:21.992]         else {
[17:28:21.992]             ...future.result["stdout"] <- base::list(NULL)
[17:28:21.992]         }
[17:28:21.992]         base::close(...future.stdout)
[17:28:21.992]         ...future.stdout <- NULL
[17:28:21.992]     }
[17:28:21.992]     ...future.result$conditions <- ...future.conditions
[17:28:21.992]     ...future.result$finished <- base::Sys.time()
[17:28:21.992]     ...future.result
[17:28:21.992] }
[17:28:21.997] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:22.007] receiveMessageFromWorker() for ClusterFuture ...
[17:28:22.008] - Validating connection of MultisessionFuture
[17:28:22.008] - received message: FutureResult
[17:28:22.008] - Received FutureResult
[17:28:22.008] - Erased future from FutureRegistry
[17:28:22.009] result() for ClusterFuture ...
[17:28:22.009] - result already collected: FutureResult
[17:28:22.009] result() for ClusterFuture ... done
[17:28:22.009] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:22.009] result() for ClusterFuture ...
[17:28:22.009] - result already collected: FutureResult
[17:28:22.010] result() for ClusterFuture ... done
[17:28:22.010] result() for ClusterFuture ...
[17:28:22.010] - result already collected: FutureResult
[17:28:22.010] result() for ClusterFuture ... done
[17:28:22.011] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:22.011] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:22.012] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:22.012] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:22.012] MultisessionFuture started
[17:28:22.013] - Launch lazy future ... done
[17:28:22.013] run() for 'MultisessionFuture' ... done
[17:28:22.013] result() for ClusterFuture ...
[17:28:22.013] - result already collected: FutureResult
[17:28:22.013] result() for ClusterFuture ... done
[17:28:22.014] result() for ClusterFuture ...
[17:28:22.014] - result already collected: FutureResult
[17:28:22.014] result() for ClusterFuture ... done
[17:28:22.014] signalConditions() ...
[17:28:22.014]  - include = 'immediateCondition'
[17:28:22.014]  - exclude = 
[17:28:22.014]  - resignal = FALSE
[17:28:22.015]  - Number of conditions: 1
[17:28:22.015] signalConditions() ... done
[17:28:22.015] Future state: 'finished'
[17:28:22.015] result() for ClusterFuture ...
[17:28:22.015] - result already collected: FutureResult
[17:28:22.015] result() for ClusterFuture ... done
[17:28:22.016] signalConditions() ...
[17:28:22.016]  - include = 'condition'
[17:28:22.016]  - exclude = 'immediateCondition'
[17:28:22.016]  - resignal = TRUE
[17:28:22.016]  - Number of conditions: 1
[17:28:22.016]  - Condition #1: 'RngFutureWarning', 'FutureWarning', 'warning', 'RngFutureCondition', 'FutureCondition', 'condition'
[17:28:22.017] signalConditions() ... done
<RngFutureWarning: UNRELIABLE VALUE: Future ('fsample_1-163723') 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: 2c96bc3a-5985-9b3f-4203-00aaa925066e


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

DEBUG: END TROUBLESHOOTING HELP
[17:28:22.018] getGlobalsAndPackages() ...
[17:28:22.018] Searching for globals...
[17:28:22.020] - globals found: [3] '{', 'sample', 'x'
[17:28:22.020] Searching for globals ... DONE
[17:28:22.020] Resolving globals: FALSE
[17:28:22.020] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:22.021] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:22.021] - globals: [1] 'x'
[17:28:22.021] 
[17:28:22.021] getGlobalsAndPackages() ... DONE
[17:28:22.022] run() for 'Future' ...
[17:28:22.022] - state: 'created'
[17:28:22.022] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:22.037] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:22.037] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:22.037]   - Field: 'node'
[17:28:22.037]   - Field: 'label'
[17:28:22.037]   - Field: 'local'
[17:28:22.037]   - Field: 'owner'
[17:28:22.038]   - Field: 'envir'
[17:28:22.038]   - Field: 'workers'
[17:28:22.038]   - Field: 'packages'
[17:28:22.038]   - Field: 'gc'
[17:28:22.038]   - Field: 'conditions'
[17:28:22.039]   - Field: 'persistent'
[17:28:22.039]   - Field: 'expr'
[17:28:22.039]   - Field: 'uuid'
[17:28:22.039]   - Field: 'seed'
[17:28:22.039]   - Field: 'version'
[17:28:22.039]   - Field: 'result'
[17:28:22.040]   - Field: 'asynchronous'
[17:28:22.040]   - Field: 'calls'
[17:28:22.040]   - Field: 'globals'
[17:28:22.040]   - Field: 'stdout'
[17:28:22.040]   - Field: 'earlySignal'
[17:28:22.040]   - Field: 'lazy'
[17:28:22.041]   - Field: 'state'
[17:28:22.041] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:22.041] - Launch lazy future ...
[17:28:22.041] Packages needed by the future expression (n = 0): <none>
[17:28:22.042] Packages needed by future strategies (n = 0): <none>
[17:28:22.042] {
[17:28:22.042]     {
[17:28:22.042]         {
[17:28:22.042]             ...future.startTime <- base::Sys.time()
[17:28:22.042]             {
[17:28:22.042]                 {
[17:28:22.042]                   {
[17:28:22.042]                     {
[17:28:22.042]                       base::local({
[17:28:22.042]                         has_future <- base::requireNamespace("future", 
[17:28:22.042]                           quietly = TRUE)
[17:28:22.042]                         if (has_future) {
[17:28:22.042]                           ns <- base::getNamespace("future")
[17:28:22.042]                           version <- ns[[".package"]][["version"]]
[17:28:22.042]                           if (is.null(version)) 
[17:28:22.042]                             version <- utils::packageVersion("future")
[17:28:22.042]                         }
[17:28:22.042]                         else {
[17:28:22.042]                           version <- NULL
[17:28:22.042]                         }
[17:28:22.042]                         if (!has_future || version < "1.8.0") {
[17:28:22.042]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:22.042]                             "", base::R.version$version.string), 
[17:28:22.042]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:22.042]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:22.042]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:22.042]                               "release", "version")], collapse = " "), 
[17:28:22.042]                             hostname = base::Sys.info()[["nodename"]])
[17:28:22.042]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:22.042]                             info)
[17:28:22.042]                           info <- base::paste(info, collapse = "; ")
[17:28:22.042]                           if (!has_future) {
[17:28:22.042]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:22.042]                               info)
[17:28:22.042]                           }
[17:28:22.042]                           else {
[17:28:22.042]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:22.042]                               info, version)
[17:28:22.042]                           }
[17:28:22.042]                           base::stop(msg)
[17:28:22.042]                         }
[17:28:22.042]                       })
[17:28:22.042]                     }
[17:28:22.042]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:22.042]                     base::options(mc.cores = 1L)
[17:28:22.042]                   }
[17:28:22.042]                   ...future.strategy.old <- future::plan("list")
[17:28:22.042]                   options(future.plan = NULL)
[17:28:22.042]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.042]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:22.042]                 }
[17:28:22.042]                 ...future.workdir <- getwd()
[17:28:22.042]             }
[17:28:22.042]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:22.042]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:22.042]         }
[17:28:22.042]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:22.042]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:22.042]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:22.042]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:22.042]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:22.042]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:22.042]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:22.042]             base::names(...future.oldOptions))
[17:28:22.042]     }
[17:28:22.042]     if (FALSE) {
[17:28:22.042]     }
[17:28:22.042]     else {
[17:28:22.042]         if (TRUE) {
[17:28:22.042]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:22.042]                 open = "w")
[17:28:22.042]         }
[17:28:22.042]         else {
[17:28:22.042]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:22.042]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:22.042]         }
[17:28:22.042]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:22.042]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:22.042]             base::sink(type = "output", split = FALSE)
[17:28:22.042]             base::close(...future.stdout)
[17:28:22.042]         }, add = TRUE)
[17:28:22.042]     }
[17:28:22.042]     ...future.frame <- base::sys.nframe()
[17:28:22.042]     ...future.conditions <- base::list()
[17:28:22.042]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:22.042]     if (FALSE) {
[17:28:22.042]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:22.042]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:22.042]     }
[17:28:22.042]     ...future.result <- base::tryCatch({
[17:28:22.042]         base::withCallingHandlers({
[17:28:22.042]             ...future.value <- base::withVisible(base::local({
[17:28:22.042]                 ...future.makeSendCondition <- base::local({
[17:28:22.042]                   sendCondition <- NULL
[17:28:22.042]                   function(frame = 1L) {
[17:28:22.042]                     if (is.function(sendCondition)) 
[17:28:22.042]                       return(sendCondition)
[17:28:22.042]                     ns <- getNamespace("parallel")
[17:28:22.042]                     if (exists("sendData", mode = "function", 
[17:28:22.042]                       envir = ns)) {
[17:28:22.042]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:22.042]                         envir = ns)
[17:28:22.042]                       envir <- sys.frame(frame)
[17:28:22.042]                       master <- NULL
[17:28:22.042]                       while (!identical(envir, .GlobalEnv) && 
[17:28:22.042]                         !identical(envir, emptyenv())) {
[17:28:22.042]                         if (exists("master", mode = "list", envir = envir, 
[17:28:22.042]                           inherits = FALSE)) {
[17:28:22.042]                           master <- get("master", mode = "list", 
[17:28:22.042]                             envir = envir, inherits = FALSE)
[17:28:22.042]                           if (inherits(master, c("SOCKnode", 
[17:28:22.042]                             "SOCK0node"))) {
[17:28:22.042]                             sendCondition <<- function(cond) {
[17:28:22.042]                               data <- list(type = "VALUE", value = cond, 
[17:28:22.042]                                 success = TRUE)
[17:28:22.042]                               parallel_sendData(master, data)
[17:28:22.042]                             }
[17:28:22.042]                             return(sendCondition)
[17:28:22.042]                           }
[17:28:22.042]                         }
[17:28:22.042]                         frame <- frame + 1L
[17:28:22.042]                         envir <- sys.frame(frame)
[17:28:22.042]                       }
[17:28:22.042]                     }
[17:28:22.042]                     sendCondition <<- function(cond) NULL
[17:28:22.042]                   }
[17:28:22.042]                 })
[17:28:22.042]                 withCallingHandlers({
[17:28:22.042]                   {
[17:28:22.042]                     sample(x, size = 1L)
[17:28:22.042]                   }
[17:28:22.042]                 }, immediateCondition = function(cond) {
[17:28:22.042]                   sendCondition <- ...future.makeSendCondition()
[17:28:22.042]                   sendCondition(cond)
[17:28:22.042]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.042]                   {
[17:28:22.042]                     inherits <- base::inherits
[17:28:22.042]                     invokeRestart <- base::invokeRestart
[17:28:22.042]                     is.null <- base::is.null
[17:28:22.042]                     muffled <- FALSE
[17:28:22.042]                     if (inherits(cond, "message")) {
[17:28:22.042]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:22.042]                       if (muffled) 
[17:28:22.042]                         invokeRestart("muffleMessage")
[17:28:22.042]                     }
[17:28:22.042]                     else if (inherits(cond, "warning")) {
[17:28:22.042]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:22.042]                       if (muffled) 
[17:28:22.042]                         invokeRestart("muffleWarning")
[17:28:22.042]                     }
[17:28:22.042]                     else if (inherits(cond, "condition")) {
[17:28:22.042]                       if (!is.null(pattern)) {
[17:28:22.042]                         computeRestarts <- base::computeRestarts
[17:28:22.042]                         grepl <- base::grepl
[17:28:22.042]                         restarts <- computeRestarts(cond)
[17:28:22.042]                         for (restart in restarts) {
[17:28:22.042]                           name <- restart$name
[17:28:22.042]                           if (is.null(name)) 
[17:28:22.042]                             next
[17:28:22.042]                           if (!grepl(pattern, name)) 
[17:28:22.042]                             next
[17:28:22.042]                           invokeRestart(restart)
[17:28:22.042]                           muffled <- TRUE
[17:28:22.042]                           break
[17:28:22.042]                         }
[17:28:22.042]                       }
[17:28:22.042]                     }
[17:28:22.042]                     invisible(muffled)
[17:28:22.042]                   }
[17:28:22.042]                   muffleCondition(cond)
[17:28:22.042]                 })
[17:28:22.042]             }))
[17:28:22.042]             future::FutureResult(value = ...future.value$value, 
[17:28:22.042]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.042]                   ...future.rng), globalenv = if (FALSE) 
[17:28:22.042]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:22.042]                     ...future.globalenv.names))
[17:28:22.042]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:22.042]         }, condition = base::local({
[17:28:22.042]             c <- base::c
[17:28:22.042]             inherits <- base::inherits
[17:28:22.042]             invokeRestart <- base::invokeRestart
[17:28:22.042]             length <- base::length
[17:28:22.042]             list <- base::list
[17:28:22.042]             seq.int <- base::seq.int
[17:28:22.042]             signalCondition <- base::signalCondition
[17:28:22.042]             sys.calls <- base::sys.calls
[17:28:22.042]             `[[` <- base::`[[`
[17:28:22.042]             `+` <- base::`+`
[17:28:22.042]             `<<-` <- base::`<<-`
[17:28:22.042]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:22.042]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:22.042]                   3L)]
[17:28:22.042]             }
[17:28:22.042]             function(cond) {
[17:28:22.042]                 is_error <- inherits(cond, "error")
[17:28:22.042]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:22.042]                   NULL)
[17:28:22.042]                 if (is_error) {
[17:28:22.042]                   sessionInformation <- function() {
[17:28:22.042]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:22.042]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:22.042]                       search = base::search(), system = base::Sys.info())
[17:28:22.042]                   }
[17:28:22.042]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.042]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:22.042]                     cond$call), session = sessionInformation(), 
[17:28:22.042]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:22.042]                   signalCondition(cond)
[17:28:22.042]                 }
[17:28:22.042]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:22.042]                 "immediateCondition"))) {
[17:28:22.042]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:22.042]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.042]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:22.042]                   if (TRUE && !signal) {
[17:28:22.042]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.042]                     {
[17:28:22.042]                       inherits <- base::inherits
[17:28:22.042]                       invokeRestart <- base::invokeRestart
[17:28:22.042]                       is.null <- base::is.null
[17:28:22.042]                       muffled <- FALSE
[17:28:22.042]                       if (inherits(cond, "message")) {
[17:28:22.042]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.042]                         if (muffled) 
[17:28:22.042]                           invokeRestart("muffleMessage")
[17:28:22.042]                       }
[17:28:22.042]                       else if (inherits(cond, "warning")) {
[17:28:22.042]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.042]                         if (muffled) 
[17:28:22.042]                           invokeRestart("muffleWarning")
[17:28:22.042]                       }
[17:28:22.042]                       else if (inherits(cond, "condition")) {
[17:28:22.042]                         if (!is.null(pattern)) {
[17:28:22.042]                           computeRestarts <- base::computeRestarts
[17:28:22.042]                           grepl <- base::grepl
[17:28:22.042]                           restarts <- computeRestarts(cond)
[17:28:22.042]                           for (restart in restarts) {
[17:28:22.042]                             name <- restart$name
[17:28:22.042]                             if (is.null(name)) 
[17:28:22.042]                               next
[17:28:22.042]                             if (!grepl(pattern, name)) 
[17:28:22.042]                               next
[17:28:22.042]                             invokeRestart(restart)
[17:28:22.042]                             muffled <- TRUE
[17:28:22.042]                             break
[17:28:22.042]                           }
[17:28:22.042]                         }
[17:28:22.042]                       }
[17:28:22.042]                       invisible(muffled)
[17:28:22.042]                     }
[17:28:22.042]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.042]                   }
[17:28:22.042]                 }
[17:28:22.042]                 else {
[17:28:22.042]                   if (TRUE) {
[17:28:22.042]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.042]                     {
[17:28:22.042]                       inherits <- base::inherits
[17:28:22.042]                       invokeRestart <- base::invokeRestart
[17:28:22.042]                       is.null <- base::is.null
[17:28:22.042]                       muffled <- FALSE
[17:28:22.042]                       if (inherits(cond, "message")) {
[17:28:22.042]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.042]                         if (muffled) 
[17:28:22.042]                           invokeRestart("muffleMessage")
[17:28:22.042]                       }
[17:28:22.042]                       else if (inherits(cond, "warning")) {
[17:28:22.042]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.042]                         if (muffled) 
[17:28:22.042]                           invokeRestart("muffleWarning")
[17:28:22.042]                       }
[17:28:22.042]                       else if (inherits(cond, "condition")) {
[17:28:22.042]                         if (!is.null(pattern)) {
[17:28:22.042]                           computeRestarts <- base::computeRestarts
[17:28:22.042]                           grepl <- base::grepl
[17:28:22.042]                           restarts <- computeRestarts(cond)
[17:28:22.042]                           for (restart in restarts) {
[17:28:22.042]                             name <- restart$name
[17:28:22.042]                             if (is.null(name)) 
[17:28:22.042]                               next
[17:28:22.042]                             if (!grepl(pattern, name)) 
[17:28:22.042]                               next
[17:28:22.042]                             invokeRestart(restart)
[17:28:22.042]                             muffled <- TRUE
[17:28:22.042]                             break
[17:28:22.042]                           }
[17:28:22.042]                         }
[17:28:22.042]                       }
[17:28:22.042]                       invisible(muffled)
[17:28:22.042]                     }
[17:28:22.042]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.042]                   }
[17:28:22.042]                 }
[17:28:22.042]             }
[17:28:22.042]         }))
[17:28:22.042]     }, error = function(ex) {
[17:28:22.042]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:22.042]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.042]                 ...future.rng), started = ...future.startTime, 
[17:28:22.042]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:22.042]             version = "1.8"), class = "FutureResult")
[17:28:22.042]     }, finally = {
[17:28:22.042]         if (!identical(...future.workdir, getwd())) 
[17:28:22.042]             setwd(...future.workdir)
[17:28:22.042]         {
[17:28:22.042]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:22.042]                 ...future.oldOptions$nwarnings <- NULL
[17:28:22.042]             }
[17:28:22.042]             base::options(...future.oldOptions)
[17:28:22.042]             if (.Platform$OS.type == "windows") {
[17:28:22.042]                 old_names <- names(...future.oldEnvVars)
[17:28:22.042]                 envs <- base::Sys.getenv()
[17:28:22.042]                 names <- names(envs)
[17:28:22.042]                 common <- intersect(names, old_names)
[17:28:22.042]                 added <- setdiff(names, old_names)
[17:28:22.042]                 removed <- setdiff(old_names, names)
[17:28:22.042]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:22.042]                   envs[common]]
[17:28:22.042]                 NAMES <- toupper(changed)
[17:28:22.042]                 args <- list()
[17:28:22.042]                 for (kk in seq_along(NAMES)) {
[17:28:22.042]                   name <- changed[[kk]]
[17:28:22.042]                   NAME <- NAMES[[kk]]
[17:28:22.042]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.042]                     next
[17:28:22.042]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.042]                 }
[17:28:22.042]                 NAMES <- toupper(added)
[17:28:22.042]                 for (kk in seq_along(NAMES)) {
[17:28:22.042]                   name <- added[[kk]]
[17:28:22.042]                   NAME <- NAMES[[kk]]
[17:28:22.042]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.042]                     next
[17:28:22.042]                   args[[name]] <- ""
[17:28:22.042]                 }
[17:28:22.042]                 NAMES <- toupper(removed)
[17:28:22.042]                 for (kk in seq_along(NAMES)) {
[17:28:22.042]                   name <- removed[[kk]]
[17:28:22.042]                   NAME <- NAMES[[kk]]
[17:28:22.042]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.042]                     next
[17:28:22.042]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.042]                 }
[17:28:22.042]                 if (length(args) > 0) 
[17:28:22.042]                   base::do.call(base::Sys.setenv, args = args)
[17:28:22.042]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:22.042]             }
[17:28:22.042]             else {
[17:28:22.042]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:22.042]             }
[17:28:22.042]             {
[17:28:22.042]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:22.042]                   0L) {
[17:28:22.042]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:22.042]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:22.042]                   base::options(opts)
[17:28:22.042]                 }
[17:28:22.042]                 {
[17:28:22.042]                   {
[17:28:22.042]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:22.042]                     NULL
[17:28:22.042]                   }
[17:28:22.042]                   options(future.plan = NULL)
[17:28:22.042]                   if (is.na(NA_character_)) 
[17:28:22.042]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.042]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:22.042]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:22.042]                     .init = FALSE)
[17:28:22.042]                 }
[17:28:22.042]             }
[17:28:22.042]         }
[17:28:22.042]     })
[17:28:22.042]     if (TRUE) {
[17:28:22.042]         base::sink(type = "output", split = FALSE)
[17:28:22.042]         if (TRUE) {
[17:28:22.042]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:22.042]         }
[17:28:22.042]         else {
[17:28:22.042]             ...future.result["stdout"] <- base::list(NULL)
[17:28:22.042]         }
[17:28:22.042]         base::close(...future.stdout)
[17:28:22.042]         ...future.stdout <- NULL
[17:28:22.042]     }
[17:28:22.042]     ...future.result$conditions <- ...future.conditions
[17:28:22.042]     ...future.result$finished <- base::Sys.time()
[17:28:22.042]     ...future.result
[17:28:22.042] }
[17:28:22.047] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:22.070] receiveMessageFromWorker() for ClusterFuture ...
[17:28:22.070] - Validating connection of MultisessionFuture
[17:28:22.070] - received message: FutureResult
[17:28:22.071] - Received FutureResult
[17:28:22.071] - Erased future from FutureRegistry
[17:28:22.071] result() for ClusterFuture ...
[17:28:22.071] - result already collected: FutureResult
[17:28:22.071] result() for ClusterFuture ... done
[17:28:22.072] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:22.072] result() for ClusterFuture ...
[17:28:22.072] - result already collected: FutureResult
[17:28:22.072] result() for ClusterFuture ... done
[17:28:22.072] result() for ClusterFuture ...
[17:28:22.072] - result already collected: FutureResult
[17:28:22.073] result() for ClusterFuture ... done
[17:28:22.073] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:22.074] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:22.074] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:22.074] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:22.075] MultisessionFuture started
[17:28:22.075] - Launch lazy future ... done
[17:28:22.075] run() for 'MultisessionFuture' ... done
[17:28:22.076] getGlobalsAndPackages() ...
[17:28:22.076] Searching for globals...
[17:28:22.077] - globals found: [3] '{', 'sample', 'x'
[17:28:22.077] Searching for globals ... DONE
[17:28:22.077] Resolving globals: FALSE
[17:28:22.078] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:22.078] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:22.079] - globals: [1] 'x'
[17:28:22.079] 
[17:28:22.079] getGlobalsAndPackages() ... DONE
[17:28:22.079] run() for 'Future' ...
[17:28:22.079] - state: 'created'
[17:28:22.080] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:22.094] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:22.094] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:22.094]   - Field: 'node'
[17:28:22.094]   - Field: 'label'
[17:28:22.095]   - Field: 'local'
[17:28:22.095]   - Field: 'owner'
[17:28:22.095]   - Field: 'envir'
[17:28:22.095]   - Field: 'workers'
[17:28:22.095]   - Field: 'packages'
[17:28:22.096]   - Field: 'gc'
[17:28:22.096]   - Field: 'conditions'
[17:28:22.096]   - Field: 'persistent'
[17:28:22.096]   - Field: 'expr'
[17:28:22.096]   - Field: 'uuid'
[17:28:22.096]   - Field: 'seed'
[17:28:22.097]   - Field: 'version'
[17:28:22.097]   - Field: 'result'
[17:28:22.097]   - Field: 'asynchronous'
[17:28:22.097]   - Field: 'calls'
[17:28:22.097]   - Field: 'globals'
[17:28:22.097]   - Field: 'stdout'
[17:28:22.098]   - Field: 'earlySignal'
[17:28:22.098]   - Field: 'lazy'
[17:28:22.098]   - Field: 'state'
[17:28:22.098] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:22.098] - Launch lazy future ...
[17:28:22.099] Packages needed by the future expression (n = 0): <none>
[17:28:22.099] Packages needed by future strategies (n = 0): <none>
[17:28:22.099] {
[17:28:22.099]     {
[17:28:22.099]         {
[17:28:22.099]             ...future.startTime <- base::Sys.time()
[17:28:22.099]             {
[17:28:22.099]                 {
[17:28:22.099]                   {
[17:28:22.099]                     {
[17:28:22.099]                       base::local({
[17:28:22.099]                         has_future <- base::requireNamespace("future", 
[17:28:22.099]                           quietly = TRUE)
[17:28:22.099]                         if (has_future) {
[17:28:22.099]                           ns <- base::getNamespace("future")
[17:28:22.099]                           version <- ns[[".package"]][["version"]]
[17:28:22.099]                           if (is.null(version)) 
[17:28:22.099]                             version <- utils::packageVersion("future")
[17:28:22.099]                         }
[17:28:22.099]                         else {
[17:28:22.099]                           version <- NULL
[17:28:22.099]                         }
[17:28:22.099]                         if (!has_future || version < "1.8.0") {
[17:28:22.099]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:22.099]                             "", base::R.version$version.string), 
[17:28:22.099]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:22.099]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:22.099]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:22.099]                               "release", "version")], collapse = " "), 
[17:28:22.099]                             hostname = base::Sys.info()[["nodename"]])
[17:28:22.099]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:22.099]                             info)
[17:28:22.099]                           info <- base::paste(info, collapse = "; ")
[17:28:22.099]                           if (!has_future) {
[17:28:22.099]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:22.099]                               info)
[17:28:22.099]                           }
[17:28:22.099]                           else {
[17:28:22.099]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:22.099]                               info, version)
[17:28:22.099]                           }
[17:28:22.099]                           base::stop(msg)
[17:28:22.099]                         }
[17:28:22.099]                       })
[17:28:22.099]                     }
[17:28:22.099]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:22.099]                     base::options(mc.cores = 1L)
[17:28:22.099]                   }
[17:28:22.099]                   ...future.strategy.old <- future::plan("list")
[17:28:22.099]                   options(future.plan = NULL)
[17:28:22.099]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.099]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:22.099]                 }
[17:28:22.099]                 ...future.workdir <- getwd()
[17:28:22.099]             }
[17:28:22.099]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:22.099]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:22.099]         }
[17:28:22.099]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:22.099]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:22.099]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:22.099]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:22.099]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:22.099]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:22.099]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:22.099]             base::names(...future.oldOptions))
[17:28:22.099]     }
[17:28:22.099]     if (FALSE) {
[17:28:22.099]     }
[17:28:22.099]     else {
[17:28:22.099]         if (TRUE) {
[17:28:22.099]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:22.099]                 open = "w")
[17:28:22.099]         }
[17:28:22.099]         else {
[17:28:22.099]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:22.099]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:22.099]         }
[17:28:22.099]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:22.099]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:22.099]             base::sink(type = "output", split = FALSE)
[17:28:22.099]             base::close(...future.stdout)
[17:28:22.099]         }, add = TRUE)
[17:28:22.099]     }
[17:28:22.099]     ...future.frame <- base::sys.nframe()
[17:28:22.099]     ...future.conditions <- base::list()
[17:28:22.099]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:22.099]     if (FALSE) {
[17:28:22.099]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:22.099]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:22.099]     }
[17:28:22.099]     ...future.result <- base::tryCatch({
[17:28:22.099]         base::withCallingHandlers({
[17:28:22.099]             ...future.value <- base::withVisible(base::local({
[17:28:22.099]                 ...future.makeSendCondition <- base::local({
[17:28:22.099]                   sendCondition <- NULL
[17:28:22.099]                   function(frame = 1L) {
[17:28:22.099]                     if (is.function(sendCondition)) 
[17:28:22.099]                       return(sendCondition)
[17:28:22.099]                     ns <- getNamespace("parallel")
[17:28:22.099]                     if (exists("sendData", mode = "function", 
[17:28:22.099]                       envir = ns)) {
[17:28:22.099]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:22.099]                         envir = ns)
[17:28:22.099]                       envir <- sys.frame(frame)
[17:28:22.099]                       master <- NULL
[17:28:22.099]                       while (!identical(envir, .GlobalEnv) && 
[17:28:22.099]                         !identical(envir, emptyenv())) {
[17:28:22.099]                         if (exists("master", mode = "list", envir = envir, 
[17:28:22.099]                           inherits = FALSE)) {
[17:28:22.099]                           master <- get("master", mode = "list", 
[17:28:22.099]                             envir = envir, inherits = FALSE)
[17:28:22.099]                           if (inherits(master, c("SOCKnode", 
[17:28:22.099]                             "SOCK0node"))) {
[17:28:22.099]                             sendCondition <<- function(cond) {
[17:28:22.099]                               data <- list(type = "VALUE", value = cond, 
[17:28:22.099]                                 success = TRUE)
[17:28:22.099]                               parallel_sendData(master, data)
[17:28:22.099]                             }
[17:28:22.099]                             return(sendCondition)
[17:28:22.099]                           }
[17:28:22.099]                         }
[17:28:22.099]                         frame <- frame + 1L
[17:28:22.099]                         envir <- sys.frame(frame)
[17:28:22.099]                       }
[17:28:22.099]                     }
[17:28:22.099]                     sendCondition <<- function(cond) NULL
[17:28:22.099]                   }
[17:28:22.099]                 })
[17:28:22.099]                 withCallingHandlers({
[17:28:22.099]                   {
[17:28:22.099]                     sample(x, size = 1L)
[17:28:22.099]                   }
[17:28:22.099]                 }, immediateCondition = function(cond) {
[17:28:22.099]                   sendCondition <- ...future.makeSendCondition()
[17:28:22.099]                   sendCondition(cond)
[17:28:22.099]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.099]                   {
[17:28:22.099]                     inherits <- base::inherits
[17:28:22.099]                     invokeRestart <- base::invokeRestart
[17:28:22.099]                     is.null <- base::is.null
[17:28:22.099]                     muffled <- FALSE
[17:28:22.099]                     if (inherits(cond, "message")) {
[17:28:22.099]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:22.099]                       if (muffled) 
[17:28:22.099]                         invokeRestart("muffleMessage")
[17:28:22.099]                     }
[17:28:22.099]                     else if (inherits(cond, "warning")) {
[17:28:22.099]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:22.099]                       if (muffled) 
[17:28:22.099]                         invokeRestart("muffleWarning")
[17:28:22.099]                     }
[17:28:22.099]                     else if (inherits(cond, "condition")) {
[17:28:22.099]                       if (!is.null(pattern)) {
[17:28:22.099]                         computeRestarts <- base::computeRestarts
[17:28:22.099]                         grepl <- base::grepl
[17:28:22.099]                         restarts <- computeRestarts(cond)
[17:28:22.099]                         for (restart in restarts) {
[17:28:22.099]                           name <- restart$name
[17:28:22.099]                           if (is.null(name)) 
[17:28:22.099]                             next
[17:28:22.099]                           if (!grepl(pattern, name)) 
[17:28:22.099]                             next
[17:28:22.099]                           invokeRestart(restart)
[17:28:22.099]                           muffled <- TRUE
[17:28:22.099]                           break
[17:28:22.099]                         }
[17:28:22.099]                       }
[17:28:22.099]                     }
[17:28:22.099]                     invisible(muffled)
[17:28:22.099]                   }
[17:28:22.099]                   muffleCondition(cond)
[17:28:22.099]                 })
[17:28:22.099]             }))
[17:28:22.099]             future::FutureResult(value = ...future.value$value, 
[17:28:22.099]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.099]                   ...future.rng), globalenv = if (FALSE) 
[17:28:22.099]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:22.099]                     ...future.globalenv.names))
[17:28:22.099]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:22.099]         }, condition = base::local({
[17:28:22.099]             c <- base::c
[17:28:22.099]             inherits <- base::inherits
[17:28:22.099]             invokeRestart <- base::invokeRestart
[17:28:22.099]             length <- base::length
[17:28:22.099]             list <- base::list
[17:28:22.099]             seq.int <- base::seq.int
[17:28:22.099]             signalCondition <- base::signalCondition
[17:28:22.099]             sys.calls <- base::sys.calls
[17:28:22.099]             `[[` <- base::`[[`
[17:28:22.099]             `+` <- base::`+`
[17:28:22.099]             `<<-` <- base::`<<-`
[17:28:22.099]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:22.099]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:22.099]                   3L)]
[17:28:22.099]             }
[17:28:22.099]             function(cond) {
[17:28:22.099]                 is_error <- inherits(cond, "error")
[17:28:22.099]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:22.099]                   NULL)
[17:28:22.099]                 if (is_error) {
[17:28:22.099]                   sessionInformation <- function() {
[17:28:22.099]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:22.099]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:22.099]                       search = base::search(), system = base::Sys.info())
[17:28:22.099]                   }
[17:28:22.099]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.099]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:22.099]                     cond$call), session = sessionInformation(), 
[17:28:22.099]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:22.099]                   signalCondition(cond)
[17:28:22.099]                 }
[17:28:22.099]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:22.099]                 "immediateCondition"))) {
[17:28:22.099]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:22.099]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.099]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:22.099]                   if (TRUE && !signal) {
[17:28:22.099]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.099]                     {
[17:28:22.099]                       inherits <- base::inherits
[17:28:22.099]                       invokeRestart <- base::invokeRestart
[17:28:22.099]                       is.null <- base::is.null
[17:28:22.099]                       muffled <- FALSE
[17:28:22.099]                       if (inherits(cond, "message")) {
[17:28:22.099]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.099]                         if (muffled) 
[17:28:22.099]                           invokeRestart("muffleMessage")
[17:28:22.099]                       }
[17:28:22.099]                       else if (inherits(cond, "warning")) {
[17:28:22.099]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.099]                         if (muffled) 
[17:28:22.099]                           invokeRestart("muffleWarning")
[17:28:22.099]                       }
[17:28:22.099]                       else if (inherits(cond, "condition")) {
[17:28:22.099]                         if (!is.null(pattern)) {
[17:28:22.099]                           computeRestarts <- base::computeRestarts
[17:28:22.099]                           grepl <- base::grepl
[17:28:22.099]                           restarts <- computeRestarts(cond)
[17:28:22.099]                           for (restart in restarts) {
[17:28:22.099]                             name <- restart$name
[17:28:22.099]                             if (is.null(name)) 
[17:28:22.099]                               next
[17:28:22.099]                             if (!grepl(pattern, name)) 
[17:28:22.099]                               next
[17:28:22.099]                             invokeRestart(restart)
[17:28:22.099]                             muffled <- TRUE
[17:28:22.099]                             break
[17:28:22.099]                           }
[17:28:22.099]                         }
[17:28:22.099]                       }
[17:28:22.099]                       invisible(muffled)
[17:28:22.099]                     }
[17:28:22.099]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.099]                   }
[17:28:22.099]                 }
[17:28:22.099]                 else {
[17:28:22.099]                   if (TRUE) {
[17:28:22.099]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.099]                     {
[17:28:22.099]                       inherits <- base::inherits
[17:28:22.099]                       invokeRestart <- base::invokeRestart
[17:28:22.099]                       is.null <- base::is.null
[17:28:22.099]                       muffled <- FALSE
[17:28:22.099]                       if (inherits(cond, "message")) {
[17:28:22.099]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.099]                         if (muffled) 
[17:28:22.099]                           invokeRestart("muffleMessage")
[17:28:22.099]                       }
[17:28:22.099]                       else if (inherits(cond, "warning")) {
[17:28:22.099]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.099]                         if (muffled) 
[17:28:22.099]                           invokeRestart("muffleWarning")
[17:28:22.099]                       }
[17:28:22.099]                       else if (inherits(cond, "condition")) {
[17:28:22.099]                         if (!is.null(pattern)) {
[17:28:22.099]                           computeRestarts <- base::computeRestarts
[17:28:22.099]                           grepl <- base::grepl
[17:28:22.099]                           restarts <- computeRestarts(cond)
[17:28:22.099]                           for (restart in restarts) {
[17:28:22.099]                             name <- restart$name
[17:28:22.099]                             if (is.null(name)) 
[17:28:22.099]                               next
[17:28:22.099]                             if (!grepl(pattern, name)) 
[17:28:22.099]                               next
[17:28:22.099]                             invokeRestart(restart)
[17:28:22.099]                             muffled <- TRUE
[17:28:22.099]                             break
[17:28:22.099]                           }
[17:28:22.099]                         }
[17:28:22.099]                       }
[17:28:22.099]                       invisible(muffled)
[17:28:22.099]                     }
[17:28:22.099]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.099]                   }
[17:28:22.099]                 }
[17:28:22.099]             }
[17:28:22.099]         }))
[17:28:22.099]     }, error = function(ex) {
[17:28:22.099]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:22.099]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.099]                 ...future.rng), started = ...future.startTime, 
[17:28:22.099]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:22.099]             version = "1.8"), class = "FutureResult")
[17:28:22.099]     }, finally = {
[17:28:22.099]         if (!identical(...future.workdir, getwd())) 
[17:28:22.099]             setwd(...future.workdir)
[17:28:22.099]         {
[17:28:22.099]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:22.099]                 ...future.oldOptions$nwarnings <- NULL
[17:28:22.099]             }
[17:28:22.099]             base::options(...future.oldOptions)
[17:28:22.099]             if (.Platform$OS.type == "windows") {
[17:28:22.099]                 old_names <- names(...future.oldEnvVars)
[17:28:22.099]                 envs <- base::Sys.getenv()
[17:28:22.099]                 names <- names(envs)
[17:28:22.099]                 common <- intersect(names, old_names)
[17:28:22.099]                 added <- setdiff(names, old_names)
[17:28:22.099]                 removed <- setdiff(old_names, names)
[17:28:22.099]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:22.099]                   envs[common]]
[17:28:22.099]                 NAMES <- toupper(changed)
[17:28:22.099]                 args <- list()
[17:28:22.099]                 for (kk in seq_along(NAMES)) {
[17:28:22.099]                   name <- changed[[kk]]
[17:28:22.099]                   NAME <- NAMES[[kk]]
[17:28:22.099]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.099]                     next
[17:28:22.099]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.099]                 }
[17:28:22.099]                 NAMES <- toupper(added)
[17:28:22.099]                 for (kk in seq_along(NAMES)) {
[17:28:22.099]                   name <- added[[kk]]
[17:28:22.099]                   NAME <- NAMES[[kk]]
[17:28:22.099]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.099]                     next
[17:28:22.099]                   args[[name]] <- ""
[17:28:22.099]                 }
[17:28:22.099]                 NAMES <- toupper(removed)
[17:28:22.099]                 for (kk in seq_along(NAMES)) {
[17:28:22.099]                   name <- removed[[kk]]
[17:28:22.099]                   NAME <- NAMES[[kk]]
[17:28:22.099]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.099]                     next
[17:28:22.099]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.099]                 }
[17:28:22.099]                 if (length(args) > 0) 
[17:28:22.099]                   base::do.call(base::Sys.setenv, args = args)
[17:28:22.099]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:22.099]             }
[17:28:22.099]             else {
[17:28:22.099]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:22.099]             }
[17:28:22.099]             {
[17:28:22.099]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:22.099]                   0L) {
[17:28:22.099]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:22.099]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:22.099]                   base::options(opts)
[17:28:22.099]                 }
[17:28:22.099]                 {
[17:28:22.099]                   {
[17:28:22.099]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:22.099]                     NULL
[17:28:22.099]                   }
[17:28:22.099]                   options(future.plan = NULL)
[17:28:22.099]                   if (is.na(NA_character_)) 
[17:28:22.099]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.099]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:22.099]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:22.099]                     .init = FALSE)
[17:28:22.099]                 }
[17:28:22.099]             }
[17:28:22.099]         }
[17:28:22.099]     })
[17:28:22.099]     if (TRUE) {
[17:28:22.099]         base::sink(type = "output", split = FALSE)
[17:28:22.099]         if (TRUE) {
[17:28:22.099]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:22.099]         }
[17:28:22.099]         else {
[17:28:22.099]             ...future.result["stdout"] <- base::list(NULL)
[17:28:22.099]         }
[17:28:22.099]         base::close(...future.stdout)
[17:28:22.099]         ...future.stdout <- NULL
[17:28:22.099]     }
[17:28:22.099]     ...future.result$conditions <- ...future.conditions
[17:28:22.099]     ...future.result$finished <- base::Sys.time()
[17:28:22.099]     ...future.result
[17:28:22.099] }
[17:28:22.104] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:22.117] receiveMessageFromWorker() for ClusterFuture ...
[17:28:22.117] - Validating connection of MultisessionFuture
[17:28:22.117] - received message: FutureResult
[17:28:22.118] - Received FutureResult
[17:28:22.118] - Erased future from FutureRegistry
[17:28:22.118] result() for ClusterFuture ...
[17:28:22.118] - result already collected: FutureResult
[17:28:22.118] result() for ClusterFuture ... done
[17:28:22.118] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:22.119] result() for ClusterFuture ...
[17:28:22.119] - result already collected: FutureResult
[17:28:22.119] result() for ClusterFuture ... done
[17:28:22.119] result() for ClusterFuture ...
[17:28:22.119] - result already collected: FutureResult
[17:28:22.119] result() for ClusterFuture ... done
[17:28:22.120] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:22.121] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:22.121] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:22.121] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:22.122] MultisessionFuture started
[17:28:22.122] - Launch lazy future ... done
[17:28:22.122] run() for 'MultisessionFuture' ... done
[17:28:22.123] getGlobalsAndPackages() ...
[17:28:22.123] Searching for globals...
[17:28:22.124] - globals found: [3] '{', 'sample', 'x'
[17:28:22.124] Searching for globals ... DONE
[17:28:22.124] Resolving globals: FALSE
[17:28:22.125] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:22.125] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:22.125] - globals: [1] 'x'
[17:28:22.126] 
[17:28:22.126] getGlobalsAndPackages() ... DONE
[17:28:22.126] run() for 'Future' ...
[17:28:22.126] - state: 'created'
[17:28:22.127] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:22.140] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:22.140] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:22.140]   - Field: 'node'
[17:28:22.140]   - Field: 'label'
[17:28:22.141]   - Field: 'local'
[17:28:22.141]   - Field: 'owner'
[17:28:22.141]   - Field: 'envir'
[17:28:22.141]   - Field: 'workers'
[17:28:22.141]   - Field: 'packages'
[17:28:22.141]   - Field: 'gc'
[17:28:22.142]   - Field: 'conditions'
[17:28:22.142]   - Field: 'persistent'
[17:28:22.142]   - Field: 'expr'
[17:28:22.142]   - Field: 'uuid'
[17:28:22.142]   - Field: 'seed'
[17:28:22.142]   - Field: 'version'
[17:28:22.143]   - Field: 'result'
[17:28:22.143]   - Field: 'asynchronous'
[17:28:22.143]   - Field: 'calls'
[17:28:22.143]   - Field: 'globals'
[17:28:22.143]   - Field: 'stdout'
[17:28:22.144]   - Field: 'earlySignal'
[17:28:22.144]   - Field: 'lazy'
[17:28:22.144]   - Field: 'state'
[17:28:22.144] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:22.144] - Launch lazy future ...
[17:28:22.145] Packages needed by the future expression (n = 0): <none>
[17:28:22.145] Packages needed by future strategies (n = 0): <none>
[17:28:22.145] {
[17:28:22.145]     {
[17:28:22.145]         {
[17:28:22.145]             ...future.startTime <- base::Sys.time()
[17:28:22.145]             {
[17:28:22.145]                 {
[17:28:22.145]                   {
[17:28:22.145]                     {
[17:28:22.145]                       base::local({
[17:28:22.145]                         has_future <- base::requireNamespace("future", 
[17:28:22.145]                           quietly = TRUE)
[17:28:22.145]                         if (has_future) {
[17:28:22.145]                           ns <- base::getNamespace("future")
[17:28:22.145]                           version <- ns[[".package"]][["version"]]
[17:28:22.145]                           if (is.null(version)) 
[17:28:22.145]                             version <- utils::packageVersion("future")
[17:28:22.145]                         }
[17:28:22.145]                         else {
[17:28:22.145]                           version <- NULL
[17:28:22.145]                         }
[17:28:22.145]                         if (!has_future || version < "1.8.0") {
[17:28:22.145]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:22.145]                             "", base::R.version$version.string), 
[17:28:22.145]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:22.145]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:22.145]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:22.145]                               "release", "version")], collapse = " "), 
[17:28:22.145]                             hostname = base::Sys.info()[["nodename"]])
[17:28:22.145]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:22.145]                             info)
[17:28:22.145]                           info <- base::paste(info, collapse = "; ")
[17:28:22.145]                           if (!has_future) {
[17:28:22.145]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:22.145]                               info)
[17:28:22.145]                           }
[17:28:22.145]                           else {
[17:28:22.145]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:22.145]                               info, version)
[17:28:22.145]                           }
[17:28:22.145]                           base::stop(msg)
[17:28:22.145]                         }
[17:28:22.145]                       })
[17:28:22.145]                     }
[17:28:22.145]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:22.145]                     base::options(mc.cores = 1L)
[17:28:22.145]                   }
[17:28:22.145]                   ...future.strategy.old <- future::plan("list")
[17:28:22.145]                   options(future.plan = NULL)
[17:28:22.145]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.145]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:22.145]                 }
[17:28:22.145]                 ...future.workdir <- getwd()
[17:28:22.145]             }
[17:28:22.145]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:22.145]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:22.145]         }
[17:28:22.145]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:22.145]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:22.145]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:22.145]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:22.145]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:22.145]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:22.145]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:22.145]             base::names(...future.oldOptions))
[17:28:22.145]     }
[17:28:22.145]     if (FALSE) {
[17:28:22.145]     }
[17:28:22.145]     else {
[17:28:22.145]         if (TRUE) {
[17:28:22.145]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:22.145]                 open = "w")
[17:28:22.145]         }
[17:28:22.145]         else {
[17:28:22.145]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:22.145]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:22.145]         }
[17:28:22.145]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:22.145]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:22.145]             base::sink(type = "output", split = FALSE)
[17:28:22.145]             base::close(...future.stdout)
[17:28:22.145]         }, add = TRUE)
[17:28:22.145]     }
[17:28:22.145]     ...future.frame <- base::sys.nframe()
[17:28:22.145]     ...future.conditions <- base::list()
[17:28:22.145]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:22.145]     if (FALSE) {
[17:28:22.145]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:22.145]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:22.145]     }
[17:28:22.145]     ...future.result <- base::tryCatch({
[17:28:22.145]         base::withCallingHandlers({
[17:28:22.145]             ...future.value <- base::withVisible(base::local({
[17:28:22.145]                 ...future.makeSendCondition <- base::local({
[17:28:22.145]                   sendCondition <- NULL
[17:28:22.145]                   function(frame = 1L) {
[17:28:22.145]                     if (is.function(sendCondition)) 
[17:28:22.145]                       return(sendCondition)
[17:28:22.145]                     ns <- getNamespace("parallel")
[17:28:22.145]                     if (exists("sendData", mode = "function", 
[17:28:22.145]                       envir = ns)) {
[17:28:22.145]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:22.145]                         envir = ns)
[17:28:22.145]                       envir <- sys.frame(frame)
[17:28:22.145]                       master <- NULL
[17:28:22.145]                       while (!identical(envir, .GlobalEnv) && 
[17:28:22.145]                         !identical(envir, emptyenv())) {
[17:28:22.145]                         if (exists("master", mode = "list", envir = envir, 
[17:28:22.145]                           inherits = FALSE)) {
[17:28:22.145]                           master <- get("master", mode = "list", 
[17:28:22.145]                             envir = envir, inherits = FALSE)
[17:28:22.145]                           if (inherits(master, c("SOCKnode", 
[17:28:22.145]                             "SOCK0node"))) {
[17:28:22.145]                             sendCondition <<- function(cond) {
[17:28:22.145]                               data <- list(type = "VALUE", value = cond, 
[17:28:22.145]                                 success = TRUE)
[17:28:22.145]                               parallel_sendData(master, data)
[17:28:22.145]                             }
[17:28:22.145]                             return(sendCondition)
[17:28:22.145]                           }
[17:28:22.145]                         }
[17:28:22.145]                         frame <- frame + 1L
[17:28:22.145]                         envir <- sys.frame(frame)
[17:28:22.145]                       }
[17:28:22.145]                     }
[17:28:22.145]                     sendCondition <<- function(cond) NULL
[17:28:22.145]                   }
[17:28:22.145]                 })
[17:28:22.145]                 withCallingHandlers({
[17:28:22.145]                   {
[17:28:22.145]                     sample(x, size = 1L)
[17:28:22.145]                   }
[17:28:22.145]                 }, immediateCondition = function(cond) {
[17:28:22.145]                   sendCondition <- ...future.makeSendCondition()
[17:28:22.145]                   sendCondition(cond)
[17:28:22.145]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.145]                   {
[17:28:22.145]                     inherits <- base::inherits
[17:28:22.145]                     invokeRestart <- base::invokeRestart
[17:28:22.145]                     is.null <- base::is.null
[17:28:22.145]                     muffled <- FALSE
[17:28:22.145]                     if (inherits(cond, "message")) {
[17:28:22.145]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:22.145]                       if (muffled) 
[17:28:22.145]                         invokeRestart("muffleMessage")
[17:28:22.145]                     }
[17:28:22.145]                     else if (inherits(cond, "warning")) {
[17:28:22.145]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:22.145]                       if (muffled) 
[17:28:22.145]                         invokeRestart("muffleWarning")
[17:28:22.145]                     }
[17:28:22.145]                     else if (inherits(cond, "condition")) {
[17:28:22.145]                       if (!is.null(pattern)) {
[17:28:22.145]                         computeRestarts <- base::computeRestarts
[17:28:22.145]                         grepl <- base::grepl
[17:28:22.145]                         restarts <- computeRestarts(cond)
[17:28:22.145]                         for (restart in restarts) {
[17:28:22.145]                           name <- restart$name
[17:28:22.145]                           if (is.null(name)) 
[17:28:22.145]                             next
[17:28:22.145]                           if (!grepl(pattern, name)) 
[17:28:22.145]                             next
[17:28:22.145]                           invokeRestart(restart)
[17:28:22.145]                           muffled <- TRUE
[17:28:22.145]                           break
[17:28:22.145]                         }
[17:28:22.145]                       }
[17:28:22.145]                     }
[17:28:22.145]                     invisible(muffled)
[17:28:22.145]                   }
[17:28:22.145]                   muffleCondition(cond)
[17:28:22.145]                 })
[17:28:22.145]             }))
[17:28:22.145]             future::FutureResult(value = ...future.value$value, 
[17:28:22.145]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.145]                   ...future.rng), globalenv = if (FALSE) 
[17:28:22.145]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:22.145]                     ...future.globalenv.names))
[17:28:22.145]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:22.145]         }, condition = base::local({
[17:28:22.145]             c <- base::c
[17:28:22.145]             inherits <- base::inherits
[17:28:22.145]             invokeRestart <- base::invokeRestart
[17:28:22.145]             length <- base::length
[17:28:22.145]             list <- base::list
[17:28:22.145]             seq.int <- base::seq.int
[17:28:22.145]             signalCondition <- base::signalCondition
[17:28:22.145]             sys.calls <- base::sys.calls
[17:28:22.145]             `[[` <- base::`[[`
[17:28:22.145]             `+` <- base::`+`
[17:28:22.145]             `<<-` <- base::`<<-`
[17:28:22.145]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:22.145]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:22.145]                   3L)]
[17:28:22.145]             }
[17:28:22.145]             function(cond) {
[17:28:22.145]                 is_error <- inherits(cond, "error")
[17:28:22.145]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:22.145]                   NULL)
[17:28:22.145]                 if (is_error) {
[17:28:22.145]                   sessionInformation <- function() {
[17:28:22.145]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:22.145]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:22.145]                       search = base::search(), system = base::Sys.info())
[17:28:22.145]                   }
[17:28:22.145]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.145]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:22.145]                     cond$call), session = sessionInformation(), 
[17:28:22.145]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:22.145]                   signalCondition(cond)
[17:28:22.145]                 }
[17:28:22.145]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:22.145]                 "immediateCondition"))) {
[17:28:22.145]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:22.145]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.145]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:22.145]                   if (TRUE && !signal) {
[17:28:22.145]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.145]                     {
[17:28:22.145]                       inherits <- base::inherits
[17:28:22.145]                       invokeRestart <- base::invokeRestart
[17:28:22.145]                       is.null <- base::is.null
[17:28:22.145]                       muffled <- FALSE
[17:28:22.145]                       if (inherits(cond, "message")) {
[17:28:22.145]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.145]                         if (muffled) 
[17:28:22.145]                           invokeRestart("muffleMessage")
[17:28:22.145]                       }
[17:28:22.145]                       else if (inherits(cond, "warning")) {
[17:28:22.145]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.145]                         if (muffled) 
[17:28:22.145]                           invokeRestart("muffleWarning")
[17:28:22.145]                       }
[17:28:22.145]                       else if (inherits(cond, "condition")) {
[17:28:22.145]                         if (!is.null(pattern)) {
[17:28:22.145]                           computeRestarts <- base::computeRestarts
[17:28:22.145]                           grepl <- base::grepl
[17:28:22.145]                           restarts <- computeRestarts(cond)
[17:28:22.145]                           for (restart in restarts) {
[17:28:22.145]                             name <- restart$name
[17:28:22.145]                             if (is.null(name)) 
[17:28:22.145]                               next
[17:28:22.145]                             if (!grepl(pattern, name)) 
[17:28:22.145]                               next
[17:28:22.145]                             invokeRestart(restart)
[17:28:22.145]                             muffled <- TRUE
[17:28:22.145]                             break
[17:28:22.145]                           }
[17:28:22.145]                         }
[17:28:22.145]                       }
[17:28:22.145]                       invisible(muffled)
[17:28:22.145]                     }
[17:28:22.145]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.145]                   }
[17:28:22.145]                 }
[17:28:22.145]                 else {
[17:28:22.145]                   if (TRUE) {
[17:28:22.145]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.145]                     {
[17:28:22.145]                       inherits <- base::inherits
[17:28:22.145]                       invokeRestart <- base::invokeRestart
[17:28:22.145]                       is.null <- base::is.null
[17:28:22.145]                       muffled <- FALSE
[17:28:22.145]                       if (inherits(cond, "message")) {
[17:28:22.145]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.145]                         if (muffled) 
[17:28:22.145]                           invokeRestart("muffleMessage")
[17:28:22.145]                       }
[17:28:22.145]                       else if (inherits(cond, "warning")) {
[17:28:22.145]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.145]                         if (muffled) 
[17:28:22.145]                           invokeRestart("muffleWarning")
[17:28:22.145]                       }
[17:28:22.145]                       else if (inherits(cond, "condition")) {
[17:28:22.145]                         if (!is.null(pattern)) {
[17:28:22.145]                           computeRestarts <- base::computeRestarts
[17:28:22.145]                           grepl <- base::grepl
[17:28:22.145]                           restarts <- computeRestarts(cond)
[17:28:22.145]                           for (restart in restarts) {
[17:28:22.145]                             name <- restart$name
[17:28:22.145]                             if (is.null(name)) 
[17:28:22.145]                               next
[17:28:22.145]                             if (!grepl(pattern, name)) 
[17:28:22.145]                               next
[17:28:22.145]                             invokeRestart(restart)
[17:28:22.145]                             muffled <- TRUE
[17:28:22.145]                             break
[17:28:22.145]                           }
[17:28:22.145]                         }
[17:28:22.145]                       }
[17:28:22.145]                       invisible(muffled)
[17:28:22.145]                     }
[17:28:22.145]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.145]                   }
[17:28:22.145]                 }
[17:28:22.145]             }
[17:28:22.145]         }))
[17:28:22.145]     }, error = function(ex) {
[17:28:22.145]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:22.145]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.145]                 ...future.rng), started = ...future.startTime, 
[17:28:22.145]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:22.145]             version = "1.8"), class = "FutureResult")
[17:28:22.145]     }, finally = {
[17:28:22.145]         if (!identical(...future.workdir, getwd())) 
[17:28:22.145]             setwd(...future.workdir)
[17:28:22.145]         {
[17:28:22.145]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:22.145]                 ...future.oldOptions$nwarnings <- NULL
[17:28:22.145]             }
[17:28:22.145]             base::options(...future.oldOptions)
[17:28:22.145]             if (.Platform$OS.type == "windows") {
[17:28:22.145]                 old_names <- names(...future.oldEnvVars)
[17:28:22.145]                 envs <- base::Sys.getenv()
[17:28:22.145]                 names <- names(envs)
[17:28:22.145]                 common <- intersect(names, old_names)
[17:28:22.145]                 added <- setdiff(names, old_names)
[17:28:22.145]                 removed <- setdiff(old_names, names)
[17:28:22.145]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:22.145]                   envs[common]]
[17:28:22.145]                 NAMES <- toupper(changed)
[17:28:22.145]                 args <- list()
[17:28:22.145]                 for (kk in seq_along(NAMES)) {
[17:28:22.145]                   name <- changed[[kk]]
[17:28:22.145]                   NAME <- NAMES[[kk]]
[17:28:22.145]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.145]                     next
[17:28:22.145]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.145]                 }
[17:28:22.145]                 NAMES <- toupper(added)
[17:28:22.145]                 for (kk in seq_along(NAMES)) {
[17:28:22.145]                   name <- added[[kk]]
[17:28:22.145]                   NAME <- NAMES[[kk]]
[17:28:22.145]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.145]                     next
[17:28:22.145]                   args[[name]] <- ""
[17:28:22.145]                 }
[17:28:22.145]                 NAMES <- toupper(removed)
[17:28:22.145]                 for (kk in seq_along(NAMES)) {
[17:28:22.145]                   name <- removed[[kk]]
[17:28:22.145]                   NAME <- NAMES[[kk]]
[17:28:22.145]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.145]                     next
[17:28:22.145]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.145]                 }
[17:28:22.145]                 if (length(args) > 0) 
[17:28:22.145]                   base::do.call(base::Sys.setenv, args = args)
[17:28:22.145]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:22.145]             }
[17:28:22.145]             else {
[17:28:22.145]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:22.145]             }
[17:28:22.145]             {
[17:28:22.145]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:22.145]                   0L) {
[17:28:22.145]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:22.145]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:22.145]                   base::options(opts)
[17:28:22.145]                 }
[17:28:22.145]                 {
[17:28:22.145]                   {
[17:28:22.145]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:22.145]                     NULL
[17:28:22.145]                   }
[17:28:22.145]                   options(future.plan = NULL)
[17:28:22.145]                   if (is.na(NA_character_)) 
[17:28:22.145]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.145]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:22.145]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:22.145]                     .init = FALSE)
[17:28:22.145]                 }
[17:28:22.145]             }
[17:28:22.145]         }
[17:28:22.145]     })
[17:28:22.145]     if (TRUE) {
[17:28:22.145]         base::sink(type = "output", split = FALSE)
[17:28:22.145]         if (TRUE) {
[17:28:22.145]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:22.145]         }
[17:28:22.145]         else {
[17:28:22.145]             ...future.result["stdout"] <- base::list(NULL)
[17:28:22.145]         }
[17:28:22.145]         base::close(...future.stdout)
[17:28:22.145]         ...future.stdout <- NULL
[17:28:22.145]     }
[17:28:22.145]     ...future.result$conditions <- ...future.conditions
[17:28:22.145]     ...future.result$finished <- base::Sys.time()
[17:28:22.145]     ...future.result
[17:28:22.145] }
[17:28:22.150] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:22.164] receiveMessageFromWorker() for ClusterFuture ...
[17:28:22.164] - Validating connection of MultisessionFuture
[17:28:22.164] - received message: FutureResult
[17:28:22.164] - Received FutureResult
[17:28:22.165] - Erased future from FutureRegistry
[17:28:22.165] result() for ClusterFuture ...
[17:28:22.165] - result already collected: FutureResult
[17:28:22.165] result() for ClusterFuture ... done
[17:28:22.165] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:22.165] result() for ClusterFuture ...
[17:28:22.166] - result already collected: FutureResult
[17:28:22.166] result() for ClusterFuture ... done
[17:28:22.166] result() for ClusterFuture ...
[17:28:22.166] - result already collected: FutureResult
[17:28:22.166] result() for ClusterFuture ... done
[17:28:22.167] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:22.167] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:22.168] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:22.168] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:22.168] MultisessionFuture started
[17:28:22.169] - Launch lazy future ... done
[17:28:22.169] run() for 'MultisessionFuture' ... done
[17:28:22.169] getGlobalsAndPackages() ...
[17:28:22.169] Searching for globals...
[17:28:22.171] - globals found: [3] '{', 'sample', 'x'
[17:28:22.171] Searching for globals ... DONE
[17:28:22.171] Resolving globals: FALSE
[17:28:22.171] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:22.172] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:22.172] - globals: [1] 'x'
[17:28:22.172] 
[17:28:22.172] getGlobalsAndPackages() ... DONE
[17:28:22.173] run() for 'Future' ...
[17:28:22.173] - state: 'created'
[17:28:22.173] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:22.186] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:22.187] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:22.187]   - Field: 'node'
[17:28:22.187]   - Field: 'label'
[17:28:22.187]   - Field: 'local'
[17:28:22.187]   - Field: 'owner'
[17:28:22.187]   - Field: 'envir'
[17:28:22.188]   - Field: 'workers'
[17:28:22.188]   - Field: 'packages'
[17:28:22.188]   - Field: 'gc'
[17:28:22.188]   - Field: 'conditions'
[17:28:22.188]   - Field: 'persistent'
[17:28:22.189]   - Field: 'expr'
[17:28:22.189]   - Field: 'uuid'
[17:28:22.189]   - Field: 'seed'
[17:28:22.189]   - Field: 'version'
[17:28:22.189]   - Field: 'result'
[17:28:22.189]   - Field: 'asynchronous'
[17:28:22.190]   - Field: 'calls'
[17:28:22.190]   - Field: 'globals'
[17:28:22.190]   - Field: 'stdout'
[17:28:22.190]   - Field: 'earlySignal'
[17:28:22.190]   - Field: 'lazy'
[17:28:22.190]   - Field: 'state'
[17:28:22.191] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:22.191] - Launch lazy future ...
[17:28:22.191] Packages needed by the future expression (n = 0): <none>
[17:28:22.191] Packages needed by future strategies (n = 0): <none>
[17:28:22.192] {
[17:28:22.192]     {
[17:28:22.192]         {
[17:28:22.192]             ...future.startTime <- base::Sys.time()
[17:28:22.192]             {
[17:28:22.192]                 {
[17:28:22.192]                   {
[17:28:22.192]                     {
[17:28:22.192]                       base::local({
[17:28:22.192]                         has_future <- base::requireNamespace("future", 
[17:28:22.192]                           quietly = TRUE)
[17:28:22.192]                         if (has_future) {
[17:28:22.192]                           ns <- base::getNamespace("future")
[17:28:22.192]                           version <- ns[[".package"]][["version"]]
[17:28:22.192]                           if (is.null(version)) 
[17:28:22.192]                             version <- utils::packageVersion("future")
[17:28:22.192]                         }
[17:28:22.192]                         else {
[17:28:22.192]                           version <- NULL
[17:28:22.192]                         }
[17:28:22.192]                         if (!has_future || version < "1.8.0") {
[17:28:22.192]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:22.192]                             "", base::R.version$version.string), 
[17:28:22.192]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:22.192]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:22.192]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:22.192]                               "release", "version")], collapse = " "), 
[17:28:22.192]                             hostname = base::Sys.info()[["nodename"]])
[17:28:22.192]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:22.192]                             info)
[17:28:22.192]                           info <- base::paste(info, collapse = "; ")
[17:28:22.192]                           if (!has_future) {
[17:28:22.192]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:22.192]                               info)
[17:28:22.192]                           }
[17:28:22.192]                           else {
[17:28:22.192]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:22.192]                               info, version)
[17:28:22.192]                           }
[17:28:22.192]                           base::stop(msg)
[17:28:22.192]                         }
[17:28:22.192]                       })
[17:28:22.192]                     }
[17:28:22.192]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:22.192]                     base::options(mc.cores = 1L)
[17:28:22.192]                   }
[17:28:22.192]                   ...future.strategy.old <- future::plan("list")
[17:28:22.192]                   options(future.plan = NULL)
[17:28:22.192]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.192]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:22.192]                 }
[17:28:22.192]                 ...future.workdir <- getwd()
[17:28:22.192]             }
[17:28:22.192]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:22.192]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:22.192]         }
[17:28:22.192]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:22.192]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:22.192]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:22.192]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:22.192]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:28:22.192]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:22.192]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:22.192]             base::names(...future.oldOptions))
[17:28:22.192]     }
[17:28:22.192]     if (FALSE) {
[17:28:22.192]     }
[17:28:22.192]     else {
[17:28:22.192]         if (TRUE) {
[17:28:22.192]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:22.192]                 open = "w")
[17:28:22.192]         }
[17:28:22.192]         else {
[17:28:22.192]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:22.192]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:22.192]         }
[17:28:22.192]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:22.192]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:22.192]             base::sink(type = "output", split = FALSE)
[17:28:22.192]             base::close(...future.stdout)
[17:28:22.192]         }, add = TRUE)
[17:28:22.192]     }
[17:28:22.192]     ...future.frame <- base::sys.nframe()
[17:28:22.192]     ...future.conditions <- base::list()
[17:28:22.192]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:22.192]     if (FALSE) {
[17:28:22.192]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:22.192]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:22.192]     }
[17:28:22.192]     ...future.result <- base::tryCatch({
[17:28:22.192]         base::withCallingHandlers({
[17:28:22.192]             ...future.value <- base::withVisible(base::local({
[17:28:22.192]                 ...future.makeSendCondition <- base::local({
[17:28:22.192]                   sendCondition <- NULL
[17:28:22.192]                   function(frame = 1L) {
[17:28:22.192]                     if (is.function(sendCondition)) 
[17:28:22.192]                       return(sendCondition)
[17:28:22.192]                     ns <- getNamespace("parallel")
[17:28:22.192]                     if (exists("sendData", mode = "function", 
[17:28:22.192]                       envir = ns)) {
[17:28:22.192]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:22.192]                         envir = ns)
[17:28:22.192]                       envir <- sys.frame(frame)
[17:28:22.192]                       master <- NULL
[17:28:22.192]                       while (!identical(envir, .GlobalEnv) && 
[17:28:22.192]                         !identical(envir, emptyenv())) {
[17:28:22.192]                         if (exists("master", mode = "list", envir = envir, 
[17:28:22.192]                           inherits = FALSE)) {
[17:28:22.192]                           master <- get("master", mode = "list", 
[17:28:22.192]                             envir = envir, inherits = FALSE)
[17:28:22.192]                           if (inherits(master, c("SOCKnode", 
[17:28:22.192]                             "SOCK0node"))) {
[17:28:22.192]                             sendCondition <<- function(cond) {
[17:28:22.192]                               data <- list(type = "VALUE", value = cond, 
[17:28:22.192]                                 success = TRUE)
[17:28:22.192]                               parallel_sendData(master, data)
[17:28:22.192]                             }
[17:28:22.192]                             return(sendCondition)
[17:28:22.192]                           }
[17:28:22.192]                         }
[17:28:22.192]                         frame <- frame + 1L
[17:28:22.192]                         envir <- sys.frame(frame)
[17:28:22.192]                       }
[17:28:22.192]                     }
[17:28:22.192]                     sendCondition <<- function(cond) NULL
[17:28:22.192]                   }
[17:28:22.192]                 })
[17:28:22.192]                 withCallingHandlers({
[17:28:22.192]                   {
[17:28:22.192]                     sample(x, size = 1L)
[17:28:22.192]                   }
[17:28:22.192]                 }, immediateCondition = function(cond) {
[17:28:22.192]                   sendCondition <- ...future.makeSendCondition()
[17:28:22.192]                   sendCondition(cond)
[17:28:22.192]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.192]                   {
[17:28:22.192]                     inherits <- base::inherits
[17:28:22.192]                     invokeRestart <- base::invokeRestart
[17:28:22.192]                     is.null <- base::is.null
[17:28:22.192]                     muffled <- FALSE
[17:28:22.192]                     if (inherits(cond, "message")) {
[17:28:22.192]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:22.192]                       if (muffled) 
[17:28:22.192]                         invokeRestart("muffleMessage")
[17:28:22.192]                     }
[17:28:22.192]                     else if (inherits(cond, "warning")) {
[17:28:22.192]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:22.192]                       if (muffled) 
[17:28:22.192]                         invokeRestart("muffleWarning")
[17:28:22.192]                     }
[17:28:22.192]                     else if (inherits(cond, "condition")) {
[17:28:22.192]                       if (!is.null(pattern)) {
[17:28:22.192]                         computeRestarts <- base::computeRestarts
[17:28:22.192]                         grepl <- base::grepl
[17:28:22.192]                         restarts <- computeRestarts(cond)
[17:28:22.192]                         for (restart in restarts) {
[17:28:22.192]                           name <- restart$name
[17:28:22.192]                           if (is.null(name)) 
[17:28:22.192]                             next
[17:28:22.192]                           if (!grepl(pattern, name)) 
[17:28:22.192]                             next
[17:28:22.192]                           invokeRestart(restart)
[17:28:22.192]                           muffled <- TRUE
[17:28:22.192]                           break
[17:28:22.192]                         }
[17:28:22.192]                       }
[17:28:22.192]                     }
[17:28:22.192]                     invisible(muffled)
[17:28:22.192]                   }
[17:28:22.192]                   muffleCondition(cond)
[17:28:22.192]                 })
[17:28:22.192]             }))
[17:28:22.192]             future::FutureResult(value = ...future.value$value, 
[17:28:22.192]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.192]                   ...future.rng), globalenv = if (FALSE) 
[17:28:22.192]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:22.192]                     ...future.globalenv.names))
[17:28:22.192]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:22.192]         }, condition = base::local({
[17:28:22.192]             c <- base::c
[17:28:22.192]             inherits <- base::inherits
[17:28:22.192]             invokeRestart <- base::invokeRestart
[17:28:22.192]             length <- base::length
[17:28:22.192]             list <- base::list
[17:28:22.192]             seq.int <- base::seq.int
[17:28:22.192]             signalCondition <- base::signalCondition
[17:28:22.192]             sys.calls <- base::sys.calls
[17:28:22.192]             `[[` <- base::`[[`
[17:28:22.192]             `+` <- base::`+`
[17:28:22.192]             `<<-` <- base::`<<-`
[17:28:22.192]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:22.192]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:22.192]                   3L)]
[17:28:22.192]             }
[17:28:22.192]             function(cond) {
[17:28:22.192]                 is_error <- inherits(cond, "error")
[17:28:22.192]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:22.192]                   NULL)
[17:28:22.192]                 if (is_error) {
[17:28:22.192]                   sessionInformation <- function() {
[17:28:22.192]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:22.192]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:22.192]                       search = base::search(), system = base::Sys.info())
[17:28:22.192]                   }
[17:28:22.192]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.192]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:22.192]                     cond$call), session = sessionInformation(), 
[17:28:22.192]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:22.192]                   signalCondition(cond)
[17:28:22.192]                 }
[17:28:22.192]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:22.192]                 "immediateCondition"))) {
[17:28:22.192]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:22.192]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.192]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:22.192]                   if (TRUE && !signal) {
[17:28:22.192]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.192]                     {
[17:28:22.192]                       inherits <- base::inherits
[17:28:22.192]                       invokeRestart <- base::invokeRestart
[17:28:22.192]                       is.null <- base::is.null
[17:28:22.192]                       muffled <- FALSE
[17:28:22.192]                       if (inherits(cond, "message")) {
[17:28:22.192]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.192]                         if (muffled) 
[17:28:22.192]                           invokeRestart("muffleMessage")
[17:28:22.192]                       }
[17:28:22.192]                       else if (inherits(cond, "warning")) {
[17:28:22.192]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.192]                         if (muffled) 
[17:28:22.192]                           invokeRestart("muffleWarning")
[17:28:22.192]                       }
[17:28:22.192]                       else if (inherits(cond, "condition")) {
[17:28:22.192]                         if (!is.null(pattern)) {
[17:28:22.192]                           computeRestarts <- base::computeRestarts
[17:28:22.192]                           grepl <- base::grepl
[17:28:22.192]                           restarts <- computeRestarts(cond)
[17:28:22.192]                           for (restart in restarts) {
[17:28:22.192]                             name <- restart$name
[17:28:22.192]                             if (is.null(name)) 
[17:28:22.192]                               next
[17:28:22.192]                             if (!grepl(pattern, name)) 
[17:28:22.192]                               next
[17:28:22.192]                             invokeRestart(restart)
[17:28:22.192]                             muffled <- TRUE
[17:28:22.192]                             break
[17:28:22.192]                           }
[17:28:22.192]                         }
[17:28:22.192]                       }
[17:28:22.192]                       invisible(muffled)
[17:28:22.192]                     }
[17:28:22.192]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.192]                   }
[17:28:22.192]                 }
[17:28:22.192]                 else {
[17:28:22.192]                   if (TRUE) {
[17:28:22.192]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.192]                     {
[17:28:22.192]                       inherits <- base::inherits
[17:28:22.192]                       invokeRestart <- base::invokeRestart
[17:28:22.192]                       is.null <- base::is.null
[17:28:22.192]                       muffled <- FALSE
[17:28:22.192]                       if (inherits(cond, "message")) {
[17:28:22.192]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.192]                         if (muffled) 
[17:28:22.192]                           invokeRestart("muffleMessage")
[17:28:22.192]                       }
[17:28:22.192]                       else if (inherits(cond, "warning")) {
[17:28:22.192]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.192]                         if (muffled) 
[17:28:22.192]                           invokeRestart("muffleWarning")
[17:28:22.192]                       }
[17:28:22.192]                       else if (inherits(cond, "condition")) {
[17:28:22.192]                         if (!is.null(pattern)) {
[17:28:22.192]                           computeRestarts <- base::computeRestarts
[17:28:22.192]                           grepl <- base::grepl
[17:28:22.192]                           restarts <- computeRestarts(cond)
[17:28:22.192]                           for (restart in restarts) {
[17:28:22.192]                             name <- restart$name
[17:28:22.192]                             if (is.null(name)) 
[17:28:22.192]                               next
[17:28:22.192]                             if (!grepl(pattern, name)) 
[17:28:22.192]                               next
[17:28:22.192]                             invokeRestart(restart)
[17:28:22.192]                             muffled <- TRUE
[17:28:22.192]                             break
[17:28:22.192]                           }
[17:28:22.192]                         }
[17:28:22.192]                       }
[17:28:22.192]                       invisible(muffled)
[17:28:22.192]                     }
[17:28:22.192]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.192]                   }
[17:28:22.192]                 }
[17:28:22.192]             }
[17:28:22.192]         }))
[17:28:22.192]     }, error = function(ex) {
[17:28:22.192]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:22.192]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.192]                 ...future.rng), started = ...future.startTime, 
[17:28:22.192]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:22.192]             version = "1.8"), class = "FutureResult")
[17:28:22.192]     }, finally = {
[17:28:22.192]         if (!identical(...future.workdir, getwd())) 
[17:28:22.192]             setwd(...future.workdir)
[17:28:22.192]         {
[17:28:22.192]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:22.192]                 ...future.oldOptions$nwarnings <- NULL
[17:28:22.192]             }
[17:28:22.192]             base::options(...future.oldOptions)
[17:28:22.192]             if (.Platform$OS.type == "windows") {
[17:28:22.192]                 old_names <- names(...future.oldEnvVars)
[17:28:22.192]                 envs <- base::Sys.getenv()
[17:28:22.192]                 names <- names(envs)
[17:28:22.192]                 common <- intersect(names, old_names)
[17:28:22.192]                 added <- setdiff(names, old_names)
[17:28:22.192]                 removed <- setdiff(old_names, names)
[17:28:22.192]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:22.192]                   envs[common]]
[17:28:22.192]                 NAMES <- toupper(changed)
[17:28:22.192]                 args <- list()
[17:28:22.192]                 for (kk in seq_along(NAMES)) {
[17:28:22.192]                   name <- changed[[kk]]
[17:28:22.192]                   NAME <- NAMES[[kk]]
[17:28:22.192]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.192]                     next
[17:28:22.192]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.192]                 }
[17:28:22.192]                 NAMES <- toupper(added)
[17:28:22.192]                 for (kk in seq_along(NAMES)) {
[17:28:22.192]                   name <- added[[kk]]
[17:28:22.192]                   NAME <- NAMES[[kk]]
[17:28:22.192]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.192]                     next
[17:28:22.192]                   args[[name]] <- ""
[17:28:22.192]                 }
[17:28:22.192]                 NAMES <- toupper(removed)
[17:28:22.192]                 for (kk in seq_along(NAMES)) {
[17:28:22.192]                   name <- removed[[kk]]
[17:28:22.192]                   NAME <- NAMES[[kk]]
[17:28:22.192]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.192]                     next
[17:28:22.192]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.192]                 }
[17:28:22.192]                 if (length(args) > 0) 
[17:28:22.192]                   base::do.call(base::Sys.setenv, args = args)
[17:28:22.192]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:22.192]             }
[17:28:22.192]             else {
[17:28:22.192]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:22.192]             }
[17:28:22.192]             {
[17:28:22.192]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:22.192]                   0L) {
[17:28:22.192]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:22.192]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:22.192]                   base::options(opts)
[17:28:22.192]                 }
[17:28:22.192]                 {
[17:28:22.192]                   {
[17:28:22.192]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:22.192]                     NULL
[17:28:22.192]                   }
[17:28:22.192]                   options(future.plan = NULL)
[17:28:22.192]                   if (is.na(NA_character_)) 
[17:28:22.192]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.192]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:22.192]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:22.192]                     .init = FALSE)
[17:28:22.192]                 }
[17:28:22.192]             }
[17:28:22.192]         }
[17:28:22.192]     })
[17:28:22.192]     if (TRUE) {
[17:28:22.192]         base::sink(type = "output", split = FALSE)
[17:28:22.192]         if (TRUE) {
[17:28:22.192]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:22.192]         }
[17:28:22.192]         else {
[17:28:22.192]             ...future.result["stdout"] <- base::list(NULL)
[17:28:22.192]         }
[17:28:22.192]         base::close(...future.stdout)
[17:28:22.192]         ...future.stdout <- NULL
[17:28:22.192]     }
[17:28:22.192]     ...future.result$conditions <- ...future.conditions
[17:28:22.192]     ...future.result$finished <- base::Sys.time()
[17:28:22.192]     ...future.result
[17:28:22.192] }
[17:28:22.197] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:22.211] receiveMessageFromWorker() for ClusterFuture ...
[17:28:22.211] - Validating connection of MultisessionFuture
[17:28:22.211] - received message: FutureResult
[17:28:22.211] - Received FutureResult
[17:28:22.211] - Erased future from FutureRegistry
[17:28:22.212] result() for ClusterFuture ...
[17:28:22.212] - result already collected: FutureResult
[17:28:22.212] result() for ClusterFuture ... done
[17:28:22.212] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:22.212] result() for ClusterFuture ...
[17:28:22.212] - result already collected: FutureResult
[17:28:22.213] result() for ClusterFuture ... done
[17:28:22.213] result() for ClusterFuture ...
[17:28:22.213] - result already collected: FutureResult
[17:28:22.213] result() for ClusterFuture ... done
[17:28:22.214] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:22.214] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:22.214] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:22.215] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:22.215] MultisessionFuture started
[17:28:22.216] - Launch lazy future ... done
[17:28:22.216] run() for 'MultisessionFuture' ... done
[17:28:22.216] result() for ClusterFuture ...
[17:28:22.216] - result already collected: FutureResult
[17:28:22.216] result() for ClusterFuture ... done
[17:28:22.216] result() for ClusterFuture ...
[17:28:22.217] - result already collected: FutureResult
[17:28:22.217] result() for ClusterFuture ... done
[17:28:22.217] result() for ClusterFuture ...
[17:28:22.217] - result already collected: FutureResult
[17:28:22.217] result() for ClusterFuture ... done
[17:28:22.217] result() for ClusterFuture ...
[17:28:22.218] - result already collected: FutureResult
[17:28:22.218] result() for ClusterFuture ... done
[17:28:22.218] result() for ClusterFuture ...
[17:28:22.218] receiveMessageFromWorker() for ClusterFuture ...
[17:28:22.218] - Validating connection of MultisessionFuture
[17:28:22.219] - received message: FutureResult
[17:28:22.219] - Received FutureResult
[17:28:22.219] - Erased future from FutureRegistry
[17:28:22.219] result() for ClusterFuture ...
[17:28:22.219] - result already collected: FutureResult
[17:28:22.219] result() for ClusterFuture ... done
[17:28:22.220] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:22.220] result() for ClusterFuture ... done
[17:28:22.220] result() for ClusterFuture ...
[17:28:22.220] - result already collected: FutureResult
[17:28:22.220] result() for ClusterFuture ... done
[17:28:22.220] result() for ClusterFuture ...
[17:28:22.221] receiveMessageFromWorker() for ClusterFuture ...
[17:28:22.221] - Validating connection of MultisessionFuture
[17:28:22.229] - received message: FutureResult
[17:28:22.229] - Received FutureResult
[17:28:22.229] - Erased future from FutureRegistry
[17:28:22.229] result() for ClusterFuture ...
[17:28:22.230] - result already collected: FutureResult
[17:28:22.230] result() for ClusterFuture ... done
[17:28:22.230] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:22.230] result() for ClusterFuture ... done
[17:28:22.230] result() for ClusterFuture ...
[17:28:22.230] - result already collected: FutureResult
[17:28:22.231] result() for ClusterFuture ... done
[[1]]
[1] 0

[[2]]
[1] 1

[[3]]
[1] 3

[[4]]
[1] 0

[17:28:22.231] getGlobalsAndPackages() ...
[17:28:22.231] Searching for globals...
[17:28:22.233] - globals found: [3] '{', 'sample', 'x'
[17:28:22.233] Searching for globals ... DONE
[17:28:22.233] Resolving globals: FALSE
[17:28:22.233] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:22.234] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:22.234] - globals: [1] 'x'
[17:28:22.234] 
[17:28:22.234] getGlobalsAndPackages() ... DONE
[17:28:22.235] run() for 'Future' ...
[17:28:22.235] - state: 'created'
[17:28:22.235] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:22.249] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:22.249] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:22.249]   - Field: 'node'
[17:28:22.249]   - Field: 'label'
[17:28:22.249]   - Field: 'local'
[17:28:22.250]   - Field: 'owner'
[17:28:22.250]   - Field: 'envir'
[17:28:22.250]   - Field: 'workers'
[17:28:22.250]   - Field: 'packages'
[17:28:22.250]   - Field: 'gc'
[17:28:22.251]   - Field: 'conditions'
[17:28:22.251]   - Field: 'persistent'
[17:28:22.251]   - Field: 'expr'
[17:28:22.251]   - Field: 'uuid'
[17:28:22.251]   - Field: 'seed'
[17:28:22.251]   - Field: 'version'
[17:28:22.252]   - Field: 'result'
[17:28:22.252]   - Field: 'asynchronous'
[17:28:22.252]   - Field: 'calls'
[17:28:22.252]   - Field: 'globals'
[17:28:22.255]   - Field: 'stdout'
[17:28:22.255]   - Field: 'earlySignal'
[17:28:22.255]   - Field: 'lazy'
[17:28:22.255]   - Field: 'state'
[17:28:22.255] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:22.256] - Launch lazy future ...
[17:28:22.256] Packages needed by the future expression (n = 0): <none>
[17:28:22.256] Packages needed by future strategies (n = 0): <none>
[17:28:22.257] {
[17:28:22.257]     {
[17:28:22.257]         {
[17:28:22.257]             ...future.startTime <- base::Sys.time()
[17:28:22.257]             {
[17:28:22.257]                 {
[17:28:22.257]                   {
[17:28:22.257]                     {
[17:28:22.257]                       base::local({
[17:28:22.257]                         has_future <- base::requireNamespace("future", 
[17:28:22.257]                           quietly = TRUE)
[17:28:22.257]                         if (has_future) {
[17:28:22.257]                           ns <- base::getNamespace("future")
[17:28:22.257]                           version <- ns[[".package"]][["version"]]
[17:28:22.257]                           if (is.null(version)) 
[17:28:22.257]                             version <- utils::packageVersion("future")
[17:28:22.257]                         }
[17:28:22.257]                         else {
[17:28:22.257]                           version <- NULL
[17:28:22.257]                         }
[17:28:22.257]                         if (!has_future || version < "1.8.0") {
[17:28:22.257]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:22.257]                             "", base::R.version$version.string), 
[17:28:22.257]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:22.257]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:22.257]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:22.257]                               "release", "version")], collapse = " "), 
[17:28:22.257]                             hostname = base::Sys.info()[["nodename"]])
[17:28:22.257]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:22.257]                             info)
[17:28:22.257]                           info <- base::paste(info, collapse = "; ")
[17:28:22.257]                           if (!has_future) {
[17:28:22.257]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:22.257]                               info)
[17:28:22.257]                           }
[17:28:22.257]                           else {
[17:28:22.257]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:22.257]                               info, version)
[17:28:22.257]                           }
[17:28:22.257]                           base::stop(msg)
[17:28:22.257]                         }
[17:28:22.257]                       })
[17:28:22.257]                     }
[17:28:22.257]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:22.257]                     base::options(mc.cores = 1L)
[17:28:22.257]                   }
[17:28:22.257]                   ...future.strategy.old <- future::plan("list")
[17:28:22.257]                   options(future.plan = NULL)
[17:28:22.257]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.257]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:22.257]                 }
[17:28:22.257]                 ...future.workdir <- getwd()
[17:28:22.257]             }
[17:28:22.257]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:22.257]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:22.257]         }
[17:28:22.257]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:22.257]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:22.257]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:22.257]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:22.257]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:22.257]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:22.257]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:22.257]             base::names(...future.oldOptions))
[17:28:22.257]     }
[17:28:22.257]     if (FALSE) {
[17:28:22.257]     }
[17:28:22.257]     else {
[17:28:22.257]         if (TRUE) {
[17:28:22.257]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:22.257]                 open = "w")
[17:28:22.257]         }
[17:28:22.257]         else {
[17:28:22.257]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:22.257]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:22.257]         }
[17:28:22.257]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:22.257]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:22.257]             base::sink(type = "output", split = FALSE)
[17:28:22.257]             base::close(...future.stdout)
[17:28:22.257]         }, add = TRUE)
[17:28:22.257]     }
[17:28:22.257]     ...future.frame <- base::sys.nframe()
[17:28:22.257]     ...future.conditions <- base::list()
[17:28:22.257]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:22.257]     if (FALSE) {
[17:28:22.257]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:22.257]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:22.257]     }
[17:28:22.257]     ...future.result <- base::tryCatch({
[17:28:22.257]         base::withCallingHandlers({
[17:28:22.257]             ...future.value <- base::withVisible(base::local({
[17:28:22.257]                 ...future.makeSendCondition <- base::local({
[17:28:22.257]                   sendCondition <- NULL
[17:28:22.257]                   function(frame = 1L) {
[17:28:22.257]                     if (is.function(sendCondition)) 
[17:28:22.257]                       return(sendCondition)
[17:28:22.257]                     ns <- getNamespace("parallel")
[17:28:22.257]                     if (exists("sendData", mode = "function", 
[17:28:22.257]                       envir = ns)) {
[17:28:22.257]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:22.257]                         envir = ns)
[17:28:22.257]                       envir <- sys.frame(frame)
[17:28:22.257]                       master <- NULL
[17:28:22.257]                       while (!identical(envir, .GlobalEnv) && 
[17:28:22.257]                         !identical(envir, emptyenv())) {
[17:28:22.257]                         if (exists("master", mode = "list", envir = envir, 
[17:28:22.257]                           inherits = FALSE)) {
[17:28:22.257]                           master <- get("master", mode = "list", 
[17:28:22.257]                             envir = envir, inherits = FALSE)
[17:28:22.257]                           if (inherits(master, c("SOCKnode", 
[17:28:22.257]                             "SOCK0node"))) {
[17:28:22.257]                             sendCondition <<- function(cond) {
[17:28:22.257]                               data <- list(type = "VALUE", value = cond, 
[17:28:22.257]                                 success = TRUE)
[17:28:22.257]                               parallel_sendData(master, data)
[17:28:22.257]                             }
[17:28:22.257]                             return(sendCondition)
[17:28:22.257]                           }
[17:28:22.257]                         }
[17:28:22.257]                         frame <- frame + 1L
[17:28:22.257]                         envir <- sys.frame(frame)
[17:28:22.257]                       }
[17:28:22.257]                     }
[17:28:22.257]                     sendCondition <<- function(cond) NULL
[17:28:22.257]                   }
[17:28:22.257]                 })
[17:28:22.257]                 withCallingHandlers({
[17:28:22.257]                   {
[17:28:22.257]                     sample(x, size = 1L)
[17:28:22.257]                   }
[17:28:22.257]                 }, immediateCondition = function(cond) {
[17:28:22.257]                   sendCondition <- ...future.makeSendCondition()
[17:28:22.257]                   sendCondition(cond)
[17:28:22.257]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.257]                   {
[17:28:22.257]                     inherits <- base::inherits
[17:28:22.257]                     invokeRestart <- base::invokeRestart
[17:28:22.257]                     is.null <- base::is.null
[17:28:22.257]                     muffled <- FALSE
[17:28:22.257]                     if (inherits(cond, "message")) {
[17:28:22.257]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:22.257]                       if (muffled) 
[17:28:22.257]                         invokeRestart("muffleMessage")
[17:28:22.257]                     }
[17:28:22.257]                     else if (inherits(cond, "warning")) {
[17:28:22.257]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:22.257]                       if (muffled) 
[17:28:22.257]                         invokeRestart("muffleWarning")
[17:28:22.257]                     }
[17:28:22.257]                     else if (inherits(cond, "condition")) {
[17:28:22.257]                       if (!is.null(pattern)) {
[17:28:22.257]                         computeRestarts <- base::computeRestarts
[17:28:22.257]                         grepl <- base::grepl
[17:28:22.257]                         restarts <- computeRestarts(cond)
[17:28:22.257]                         for (restart in restarts) {
[17:28:22.257]                           name <- restart$name
[17:28:22.257]                           if (is.null(name)) 
[17:28:22.257]                             next
[17:28:22.257]                           if (!grepl(pattern, name)) 
[17:28:22.257]                             next
[17:28:22.257]                           invokeRestart(restart)
[17:28:22.257]                           muffled <- TRUE
[17:28:22.257]                           break
[17:28:22.257]                         }
[17:28:22.257]                       }
[17:28:22.257]                     }
[17:28:22.257]                     invisible(muffled)
[17:28:22.257]                   }
[17:28:22.257]                   muffleCondition(cond)
[17:28:22.257]                 })
[17:28:22.257]             }))
[17:28:22.257]             future::FutureResult(value = ...future.value$value, 
[17:28:22.257]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.257]                   ...future.rng), globalenv = if (FALSE) 
[17:28:22.257]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:22.257]                     ...future.globalenv.names))
[17:28:22.257]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:22.257]         }, condition = base::local({
[17:28:22.257]             c <- base::c
[17:28:22.257]             inherits <- base::inherits
[17:28:22.257]             invokeRestart <- base::invokeRestart
[17:28:22.257]             length <- base::length
[17:28:22.257]             list <- base::list
[17:28:22.257]             seq.int <- base::seq.int
[17:28:22.257]             signalCondition <- base::signalCondition
[17:28:22.257]             sys.calls <- base::sys.calls
[17:28:22.257]             `[[` <- base::`[[`
[17:28:22.257]             `+` <- base::`+`
[17:28:22.257]             `<<-` <- base::`<<-`
[17:28:22.257]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:22.257]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:22.257]                   3L)]
[17:28:22.257]             }
[17:28:22.257]             function(cond) {
[17:28:22.257]                 is_error <- inherits(cond, "error")
[17:28:22.257]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:22.257]                   NULL)
[17:28:22.257]                 if (is_error) {
[17:28:22.257]                   sessionInformation <- function() {
[17:28:22.257]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:22.257]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:22.257]                       search = base::search(), system = base::Sys.info())
[17:28:22.257]                   }
[17:28:22.257]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.257]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:22.257]                     cond$call), session = sessionInformation(), 
[17:28:22.257]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:22.257]                   signalCondition(cond)
[17:28:22.257]                 }
[17:28:22.257]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:22.257]                 "immediateCondition"))) {
[17:28:22.257]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:22.257]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.257]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:22.257]                   if (TRUE && !signal) {
[17:28:22.257]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.257]                     {
[17:28:22.257]                       inherits <- base::inherits
[17:28:22.257]                       invokeRestart <- base::invokeRestart
[17:28:22.257]                       is.null <- base::is.null
[17:28:22.257]                       muffled <- FALSE
[17:28:22.257]                       if (inherits(cond, "message")) {
[17:28:22.257]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.257]                         if (muffled) 
[17:28:22.257]                           invokeRestart("muffleMessage")
[17:28:22.257]                       }
[17:28:22.257]                       else if (inherits(cond, "warning")) {
[17:28:22.257]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.257]                         if (muffled) 
[17:28:22.257]                           invokeRestart("muffleWarning")
[17:28:22.257]                       }
[17:28:22.257]                       else if (inherits(cond, "condition")) {
[17:28:22.257]                         if (!is.null(pattern)) {
[17:28:22.257]                           computeRestarts <- base::computeRestarts
[17:28:22.257]                           grepl <- base::grepl
[17:28:22.257]                           restarts <- computeRestarts(cond)
[17:28:22.257]                           for (restart in restarts) {
[17:28:22.257]                             name <- restart$name
[17:28:22.257]                             if (is.null(name)) 
[17:28:22.257]                               next
[17:28:22.257]                             if (!grepl(pattern, name)) 
[17:28:22.257]                               next
[17:28:22.257]                             invokeRestart(restart)
[17:28:22.257]                             muffled <- TRUE
[17:28:22.257]                             break
[17:28:22.257]                           }
[17:28:22.257]                         }
[17:28:22.257]                       }
[17:28:22.257]                       invisible(muffled)
[17:28:22.257]                     }
[17:28:22.257]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.257]                   }
[17:28:22.257]                 }
[17:28:22.257]                 else {
[17:28:22.257]                   if (TRUE) {
[17:28:22.257]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.257]                     {
[17:28:22.257]                       inherits <- base::inherits
[17:28:22.257]                       invokeRestart <- base::invokeRestart
[17:28:22.257]                       is.null <- base::is.null
[17:28:22.257]                       muffled <- FALSE
[17:28:22.257]                       if (inherits(cond, "message")) {
[17:28:22.257]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.257]                         if (muffled) 
[17:28:22.257]                           invokeRestart("muffleMessage")
[17:28:22.257]                       }
[17:28:22.257]                       else if (inherits(cond, "warning")) {
[17:28:22.257]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.257]                         if (muffled) 
[17:28:22.257]                           invokeRestart("muffleWarning")
[17:28:22.257]                       }
[17:28:22.257]                       else if (inherits(cond, "condition")) {
[17:28:22.257]                         if (!is.null(pattern)) {
[17:28:22.257]                           computeRestarts <- base::computeRestarts
[17:28:22.257]                           grepl <- base::grepl
[17:28:22.257]                           restarts <- computeRestarts(cond)
[17:28:22.257]                           for (restart in restarts) {
[17:28:22.257]                             name <- restart$name
[17:28:22.257]                             if (is.null(name)) 
[17:28:22.257]                               next
[17:28:22.257]                             if (!grepl(pattern, name)) 
[17:28:22.257]                               next
[17:28:22.257]                             invokeRestart(restart)
[17:28:22.257]                             muffled <- TRUE
[17:28:22.257]                             break
[17:28:22.257]                           }
[17:28:22.257]                         }
[17:28:22.257]                       }
[17:28:22.257]                       invisible(muffled)
[17:28:22.257]                     }
[17:28:22.257]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.257]                   }
[17:28:22.257]                 }
[17:28:22.257]             }
[17:28:22.257]         }))
[17:28:22.257]     }, error = function(ex) {
[17:28:22.257]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:22.257]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.257]                 ...future.rng), started = ...future.startTime, 
[17:28:22.257]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:22.257]             version = "1.8"), class = "FutureResult")
[17:28:22.257]     }, finally = {
[17:28:22.257]         if (!identical(...future.workdir, getwd())) 
[17:28:22.257]             setwd(...future.workdir)
[17:28:22.257]         {
[17:28:22.257]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:22.257]                 ...future.oldOptions$nwarnings <- NULL
[17:28:22.257]             }
[17:28:22.257]             base::options(...future.oldOptions)
[17:28:22.257]             if (.Platform$OS.type == "windows") {
[17:28:22.257]                 old_names <- names(...future.oldEnvVars)
[17:28:22.257]                 envs <- base::Sys.getenv()
[17:28:22.257]                 names <- names(envs)
[17:28:22.257]                 common <- intersect(names, old_names)
[17:28:22.257]                 added <- setdiff(names, old_names)
[17:28:22.257]                 removed <- setdiff(old_names, names)
[17:28:22.257]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:22.257]                   envs[common]]
[17:28:22.257]                 NAMES <- toupper(changed)
[17:28:22.257]                 args <- list()
[17:28:22.257]                 for (kk in seq_along(NAMES)) {
[17:28:22.257]                   name <- changed[[kk]]
[17:28:22.257]                   NAME <- NAMES[[kk]]
[17:28:22.257]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.257]                     next
[17:28:22.257]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.257]                 }
[17:28:22.257]                 NAMES <- toupper(added)
[17:28:22.257]                 for (kk in seq_along(NAMES)) {
[17:28:22.257]                   name <- added[[kk]]
[17:28:22.257]                   NAME <- NAMES[[kk]]
[17:28:22.257]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.257]                     next
[17:28:22.257]                   args[[name]] <- ""
[17:28:22.257]                 }
[17:28:22.257]                 NAMES <- toupper(removed)
[17:28:22.257]                 for (kk in seq_along(NAMES)) {
[17:28:22.257]                   name <- removed[[kk]]
[17:28:22.257]                   NAME <- NAMES[[kk]]
[17:28:22.257]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.257]                     next
[17:28:22.257]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.257]                 }
[17:28:22.257]                 if (length(args) > 0) 
[17:28:22.257]                   base::do.call(base::Sys.setenv, args = args)
[17:28:22.257]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:22.257]             }
[17:28:22.257]             else {
[17:28:22.257]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:22.257]             }
[17:28:22.257]             {
[17:28:22.257]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:22.257]                   0L) {
[17:28:22.257]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:22.257]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:22.257]                   base::options(opts)
[17:28:22.257]                 }
[17:28:22.257]                 {
[17:28:22.257]                   {
[17:28:22.257]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:22.257]                     NULL
[17:28:22.257]                   }
[17:28:22.257]                   options(future.plan = NULL)
[17:28:22.257]                   if (is.na(NA_character_)) 
[17:28:22.257]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.257]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:22.257]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:22.257]                     .init = FALSE)
[17:28:22.257]                 }
[17:28:22.257]             }
[17:28:22.257]         }
[17:28:22.257]     })
[17:28:22.257]     if (TRUE) {
[17:28:22.257]         base::sink(type = "output", split = FALSE)
[17:28:22.257]         if (TRUE) {
[17:28:22.257]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:22.257]         }
[17:28:22.257]         else {
[17:28:22.257]             ...future.result["stdout"] <- base::list(NULL)
[17:28:22.257]         }
[17:28:22.257]         base::close(...future.stdout)
[17:28:22.257]         ...future.stdout <- NULL
[17:28:22.257]     }
[17:28:22.257]     ...future.result$conditions <- ...future.conditions
[17:28:22.257]     ...future.result$finished <- base::Sys.time()
[17:28:22.257]     ...future.result
[17:28:22.257] }
[17:28:22.262] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:22.262] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:22.262] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:22.263] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:22.263] MultisessionFuture started
[17:28:22.263] - Launch lazy future ... done
[17:28:22.263] run() for 'MultisessionFuture' ... done
[17:28:22.264] getGlobalsAndPackages() ...
[17:28:22.264] Searching for globals...
[17:28:22.265] - globals found: [3] '{', 'sample', 'x'
[17:28:22.266] Searching for globals ... DONE
[17:28:22.266] Resolving globals: FALSE
[17:28:22.266] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:22.267] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:22.267] - globals: [1] 'x'
[17:28:22.267] 
[17:28:22.267] getGlobalsAndPackages() ... DONE
[17:28:22.267] run() for 'Future' ...
[17:28:22.268] - state: 'created'
[17:28:22.268] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:22.282] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:22.282] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:22.282]   - Field: 'node'
[17:28:22.282]   - Field: 'label'
[17:28:22.282]   - Field: 'local'
[17:28:22.283]   - Field: 'owner'
[17:28:22.283]   - Field: 'envir'
[17:28:22.283]   - Field: 'workers'
[17:28:22.283]   - Field: 'packages'
[17:28:22.283]   - Field: 'gc'
[17:28:22.283]   - Field: 'conditions'
[17:28:22.284]   - Field: 'persistent'
[17:28:22.284]   - Field: 'expr'
[17:28:22.284]   - Field: 'uuid'
[17:28:22.284]   - Field: 'seed'
[17:28:22.284]   - Field: 'version'
[17:28:22.285]   - Field: 'result'
[17:28:22.285]   - Field: 'asynchronous'
[17:28:22.285]   - Field: 'calls'
[17:28:22.285]   - Field: 'globals'
[17:28:22.285]   - Field: 'stdout'
[17:28:22.285]   - Field: 'earlySignal'
[17:28:22.286]   - Field: 'lazy'
[17:28:22.286]   - Field: 'state'
[17:28:22.286] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:22.286] - Launch lazy future ...
[17:28:22.286] Packages needed by the future expression (n = 0): <none>
[17:28:22.287] Packages needed by future strategies (n = 0): <none>
[17:28:22.287] {
[17:28:22.287]     {
[17:28:22.287]         {
[17:28:22.287]             ...future.startTime <- base::Sys.time()
[17:28:22.287]             {
[17:28:22.287]                 {
[17:28:22.287]                   {
[17:28:22.287]                     {
[17:28:22.287]                       base::local({
[17:28:22.287]                         has_future <- base::requireNamespace("future", 
[17:28:22.287]                           quietly = TRUE)
[17:28:22.287]                         if (has_future) {
[17:28:22.287]                           ns <- base::getNamespace("future")
[17:28:22.287]                           version <- ns[[".package"]][["version"]]
[17:28:22.287]                           if (is.null(version)) 
[17:28:22.287]                             version <- utils::packageVersion("future")
[17:28:22.287]                         }
[17:28:22.287]                         else {
[17:28:22.287]                           version <- NULL
[17:28:22.287]                         }
[17:28:22.287]                         if (!has_future || version < "1.8.0") {
[17:28:22.287]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:22.287]                             "", base::R.version$version.string), 
[17:28:22.287]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:22.287]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:22.287]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:22.287]                               "release", "version")], collapse = " "), 
[17:28:22.287]                             hostname = base::Sys.info()[["nodename"]])
[17:28:22.287]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:22.287]                             info)
[17:28:22.287]                           info <- base::paste(info, collapse = "; ")
[17:28:22.287]                           if (!has_future) {
[17:28:22.287]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:22.287]                               info)
[17:28:22.287]                           }
[17:28:22.287]                           else {
[17:28:22.287]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:22.287]                               info, version)
[17:28:22.287]                           }
[17:28:22.287]                           base::stop(msg)
[17:28:22.287]                         }
[17:28:22.287]                       })
[17:28:22.287]                     }
[17:28:22.287]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:22.287]                     base::options(mc.cores = 1L)
[17:28:22.287]                   }
[17:28:22.287]                   ...future.strategy.old <- future::plan("list")
[17:28:22.287]                   options(future.plan = NULL)
[17:28:22.287]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.287]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:22.287]                 }
[17:28:22.287]                 ...future.workdir <- getwd()
[17:28:22.287]             }
[17:28:22.287]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:22.287]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:22.287]         }
[17:28:22.287]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:22.287]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:22.287]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:22.287]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:22.287]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:22.287]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:22.287]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:22.287]             base::names(...future.oldOptions))
[17:28:22.287]     }
[17:28:22.287]     if (FALSE) {
[17:28:22.287]     }
[17:28:22.287]     else {
[17:28:22.287]         if (TRUE) {
[17:28:22.287]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:22.287]                 open = "w")
[17:28:22.287]         }
[17:28:22.287]         else {
[17:28:22.287]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:22.287]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:22.287]         }
[17:28:22.287]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:22.287]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:22.287]             base::sink(type = "output", split = FALSE)
[17:28:22.287]             base::close(...future.stdout)
[17:28:22.287]         }, add = TRUE)
[17:28:22.287]     }
[17:28:22.287]     ...future.frame <- base::sys.nframe()
[17:28:22.287]     ...future.conditions <- base::list()
[17:28:22.287]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:22.287]     if (FALSE) {
[17:28:22.287]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:22.287]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:22.287]     }
[17:28:22.287]     ...future.result <- base::tryCatch({
[17:28:22.287]         base::withCallingHandlers({
[17:28:22.287]             ...future.value <- base::withVisible(base::local({
[17:28:22.287]                 ...future.makeSendCondition <- base::local({
[17:28:22.287]                   sendCondition <- NULL
[17:28:22.287]                   function(frame = 1L) {
[17:28:22.287]                     if (is.function(sendCondition)) 
[17:28:22.287]                       return(sendCondition)
[17:28:22.287]                     ns <- getNamespace("parallel")
[17:28:22.287]                     if (exists("sendData", mode = "function", 
[17:28:22.287]                       envir = ns)) {
[17:28:22.287]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:22.287]                         envir = ns)
[17:28:22.287]                       envir <- sys.frame(frame)
[17:28:22.287]                       master <- NULL
[17:28:22.287]                       while (!identical(envir, .GlobalEnv) && 
[17:28:22.287]                         !identical(envir, emptyenv())) {
[17:28:22.287]                         if (exists("master", mode = "list", envir = envir, 
[17:28:22.287]                           inherits = FALSE)) {
[17:28:22.287]                           master <- get("master", mode = "list", 
[17:28:22.287]                             envir = envir, inherits = FALSE)
[17:28:22.287]                           if (inherits(master, c("SOCKnode", 
[17:28:22.287]                             "SOCK0node"))) {
[17:28:22.287]                             sendCondition <<- function(cond) {
[17:28:22.287]                               data <- list(type = "VALUE", value = cond, 
[17:28:22.287]                                 success = TRUE)
[17:28:22.287]                               parallel_sendData(master, data)
[17:28:22.287]                             }
[17:28:22.287]                             return(sendCondition)
[17:28:22.287]                           }
[17:28:22.287]                         }
[17:28:22.287]                         frame <- frame + 1L
[17:28:22.287]                         envir <- sys.frame(frame)
[17:28:22.287]                       }
[17:28:22.287]                     }
[17:28:22.287]                     sendCondition <<- function(cond) NULL
[17:28:22.287]                   }
[17:28:22.287]                 })
[17:28:22.287]                 withCallingHandlers({
[17:28:22.287]                   {
[17:28:22.287]                     sample(x, size = 1L)
[17:28:22.287]                   }
[17:28:22.287]                 }, immediateCondition = function(cond) {
[17:28:22.287]                   sendCondition <- ...future.makeSendCondition()
[17:28:22.287]                   sendCondition(cond)
[17:28:22.287]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.287]                   {
[17:28:22.287]                     inherits <- base::inherits
[17:28:22.287]                     invokeRestart <- base::invokeRestart
[17:28:22.287]                     is.null <- base::is.null
[17:28:22.287]                     muffled <- FALSE
[17:28:22.287]                     if (inherits(cond, "message")) {
[17:28:22.287]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:22.287]                       if (muffled) 
[17:28:22.287]                         invokeRestart("muffleMessage")
[17:28:22.287]                     }
[17:28:22.287]                     else if (inherits(cond, "warning")) {
[17:28:22.287]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:22.287]                       if (muffled) 
[17:28:22.287]                         invokeRestart("muffleWarning")
[17:28:22.287]                     }
[17:28:22.287]                     else if (inherits(cond, "condition")) {
[17:28:22.287]                       if (!is.null(pattern)) {
[17:28:22.287]                         computeRestarts <- base::computeRestarts
[17:28:22.287]                         grepl <- base::grepl
[17:28:22.287]                         restarts <- computeRestarts(cond)
[17:28:22.287]                         for (restart in restarts) {
[17:28:22.287]                           name <- restart$name
[17:28:22.287]                           if (is.null(name)) 
[17:28:22.287]                             next
[17:28:22.287]                           if (!grepl(pattern, name)) 
[17:28:22.287]                             next
[17:28:22.287]                           invokeRestart(restart)
[17:28:22.287]                           muffled <- TRUE
[17:28:22.287]                           break
[17:28:22.287]                         }
[17:28:22.287]                       }
[17:28:22.287]                     }
[17:28:22.287]                     invisible(muffled)
[17:28:22.287]                   }
[17:28:22.287]                   muffleCondition(cond)
[17:28:22.287]                 })
[17:28:22.287]             }))
[17:28:22.287]             future::FutureResult(value = ...future.value$value, 
[17:28:22.287]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.287]                   ...future.rng), globalenv = if (FALSE) 
[17:28:22.287]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:22.287]                     ...future.globalenv.names))
[17:28:22.287]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:22.287]         }, condition = base::local({
[17:28:22.287]             c <- base::c
[17:28:22.287]             inherits <- base::inherits
[17:28:22.287]             invokeRestart <- base::invokeRestart
[17:28:22.287]             length <- base::length
[17:28:22.287]             list <- base::list
[17:28:22.287]             seq.int <- base::seq.int
[17:28:22.287]             signalCondition <- base::signalCondition
[17:28:22.287]             sys.calls <- base::sys.calls
[17:28:22.287]             `[[` <- base::`[[`
[17:28:22.287]             `+` <- base::`+`
[17:28:22.287]             `<<-` <- base::`<<-`
[17:28:22.287]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:22.287]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:22.287]                   3L)]
[17:28:22.287]             }
[17:28:22.287]             function(cond) {
[17:28:22.287]                 is_error <- inherits(cond, "error")
[17:28:22.287]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:22.287]                   NULL)
[17:28:22.287]                 if (is_error) {
[17:28:22.287]                   sessionInformation <- function() {
[17:28:22.287]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:22.287]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:22.287]                       search = base::search(), system = base::Sys.info())
[17:28:22.287]                   }
[17:28:22.287]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.287]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:22.287]                     cond$call), session = sessionInformation(), 
[17:28:22.287]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:22.287]                   signalCondition(cond)
[17:28:22.287]                 }
[17:28:22.287]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:22.287]                 "immediateCondition"))) {
[17:28:22.287]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:22.287]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.287]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:22.287]                   if (TRUE && !signal) {
[17:28:22.287]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.287]                     {
[17:28:22.287]                       inherits <- base::inherits
[17:28:22.287]                       invokeRestart <- base::invokeRestart
[17:28:22.287]                       is.null <- base::is.null
[17:28:22.287]                       muffled <- FALSE
[17:28:22.287]                       if (inherits(cond, "message")) {
[17:28:22.287]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.287]                         if (muffled) 
[17:28:22.287]                           invokeRestart("muffleMessage")
[17:28:22.287]                       }
[17:28:22.287]                       else if (inherits(cond, "warning")) {
[17:28:22.287]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.287]                         if (muffled) 
[17:28:22.287]                           invokeRestart("muffleWarning")
[17:28:22.287]                       }
[17:28:22.287]                       else if (inherits(cond, "condition")) {
[17:28:22.287]                         if (!is.null(pattern)) {
[17:28:22.287]                           computeRestarts <- base::computeRestarts
[17:28:22.287]                           grepl <- base::grepl
[17:28:22.287]                           restarts <- computeRestarts(cond)
[17:28:22.287]                           for (restart in restarts) {
[17:28:22.287]                             name <- restart$name
[17:28:22.287]                             if (is.null(name)) 
[17:28:22.287]                               next
[17:28:22.287]                             if (!grepl(pattern, name)) 
[17:28:22.287]                               next
[17:28:22.287]                             invokeRestart(restart)
[17:28:22.287]                             muffled <- TRUE
[17:28:22.287]                             break
[17:28:22.287]                           }
[17:28:22.287]                         }
[17:28:22.287]                       }
[17:28:22.287]                       invisible(muffled)
[17:28:22.287]                     }
[17:28:22.287]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.287]                   }
[17:28:22.287]                 }
[17:28:22.287]                 else {
[17:28:22.287]                   if (TRUE) {
[17:28:22.287]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.287]                     {
[17:28:22.287]                       inherits <- base::inherits
[17:28:22.287]                       invokeRestart <- base::invokeRestart
[17:28:22.287]                       is.null <- base::is.null
[17:28:22.287]                       muffled <- FALSE
[17:28:22.287]                       if (inherits(cond, "message")) {
[17:28:22.287]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.287]                         if (muffled) 
[17:28:22.287]                           invokeRestart("muffleMessage")
[17:28:22.287]                       }
[17:28:22.287]                       else if (inherits(cond, "warning")) {
[17:28:22.287]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.287]                         if (muffled) 
[17:28:22.287]                           invokeRestart("muffleWarning")
[17:28:22.287]                       }
[17:28:22.287]                       else if (inherits(cond, "condition")) {
[17:28:22.287]                         if (!is.null(pattern)) {
[17:28:22.287]                           computeRestarts <- base::computeRestarts
[17:28:22.287]                           grepl <- base::grepl
[17:28:22.287]                           restarts <- computeRestarts(cond)
[17:28:22.287]                           for (restart in restarts) {
[17:28:22.287]                             name <- restart$name
[17:28:22.287]                             if (is.null(name)) 
[17:28:22.287]                               next
[17:28:22.287]                             if (!grepl(pattern, name)) 
[17:28:22.287]                               next
[17:28:22.287]                             invokeRestart(restart)
[17:28:22.287]                             muffled <- TRUE
[17:28:22.287]                             break
[17:28:22.287]                           }
[17:28:22.287]                         }
[17:28:22.287]                       }
[17:28:22.287]                       invisible(muffled)
[17:28:22.287]                     }
[17:28:22.287]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.287]                   }
[17:28:22.287]                 }
[17:28:22.287]             }
[17:28:22.287]         }))
[17:28:22.287]     }, error = function(ex) {
[17:28:22.287]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:22.287]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.287]                 ...future.rng), started = ...future.startTime, 
[17:28:22.287]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:22.287]             version = "1.8"), class = "FutureResult")
[17:28:22.287]     }, finally = {
[17:28:22.287]         if (!identical(...future.workdir, getwd())) 
[17:28:22.287]             setwd(...future.workdir)
[17:28:22.287]         {
[17:28:22.287]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:22.287]                 ...future.oldOptions$nwarnings <- NULL
[17:28:22.287]             }
[17:28:22.287]             base::options(...future.oldOptions)
[17:28:22.287]             if (.Platform$OS.type == "windows") {
[17:28:22.287]                 old_names <- names(...future.oldEnvVars)
[17:28:22.287]                 envs <- base::Sys.getenv()
[17:28:22.287]                 names <- names(envs)
[17:28:22.287]                 common <- intersect(names, old_names)
[17:28:22.287]                 added <- setdiff(names, old_names)
[17:28:22.287]                 removed <- setdiff(old_names, names)
[17:28:22.287]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:22.287]                   envs[common]]
[17:28:22.287]                 NAMES <- toupper(changed)
[17:28:22.287]                 args <- list()
[17:28:22.287]                 for (kk in seq_along(NAMES)) {
[17:28:22.287]                   name <- changed[[kk]]
[17:28:22.287]                   NAME <- NAMES[[kk]]
[17:28:22.287]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.287]                     next
[17:28:22.287]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.287]                 }
[17:28:22.287]                 NAMES <- toupper(added)
[17:28:22.287]                 for (kk in seq_along(NAMES)) {
[17:28:22.287]                   name <- added[[kk]]
[17:28:22.287]                   NAME <- NAMES[[kk]]
[17:28:22.287]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.287]                     next
[17:28:22.287]                   args[[name]] <- ""
[17:28:22.287]                 }
[17:28:22.287]                 NAMES <- toupper(removed)
[17:28:22.287]                 for (kk in seq_along(NAMES)) {
[17:28:22.287]                   name <- removed[[kk]]
[17:28:22.287]                   NAME <- NAMES[[kk]]
[17:28:22.287]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.287]                     next
[17:28:22.287]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.287]                 }
[17:28:22.287]                 if (length(args) > 0) 
[17:28:22.287]                   base::do.call(base::Sys.setenv, args = args)
[17:28:22.287]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:22.287]             }
[17:28:22.287]             else {
[17:28:22.287]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:22.287]             }
[17:28:22.287]             {
[17:28:22.287]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:22.287]                   0L) {
[17:28:22.287]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:22.287]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:22.287]                   base::options(opts)
[17:28:22.287]                 }
[17:28:22.287]                 {
[17:28:22.287]                   {
[17:28:22.287]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:22.287]                     NULL
[17:28:22.287]                   }
[17:28:22.287]                   options(future.plan = NULL)
[17:28:22.287]                   if (is.na(NA_character_)) 
[17:28:22.287]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.287]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:22.287]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:22.287]                     .init = FALSE)
[17:28:22.287]                 }
[17:28:22.287]             }
[17:28:22.287]         }
[17:28:22.287]     })
[17:28:22.287]     if (TRUE) {
[17:28:22.287]         base::sink(type = "output", split = FALSE)
[17:28:22.287]         if (TRUE) {
[17:28:22.287]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:22.287]         }
[17:28:22.287]         else {
[17:28:22.287]             ...future.result["stdout"] <- base::list(NULL)
[17:28:22.287]         }
[17:28:22.287]         base::close(...future.stdout)
[17:28:22.287]         ...future.stdout <- NULL
[17:28:22.287]     }
[17:28:22.287]     ...future.result$conditions <- ...future.conditions
[17:28:22.287]     ...future.result$finished <- base::Sys.time()
[17:28:22.287]     ...future.result
[17:28:22.287] }
[17:28:22.292] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:22.293] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:22.293] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:22.293] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:22.294] MultisessionFuture started
[17:28:22.294] - Launch lazy future ... done
[17:28:22.294] run() for 'MultisessionFuture' ... done
[17:28:22.295] getGlobalsAndPackages() ...
[17:28:22.295] Searching for globals...
[17:28:22.296] - globals found: [3] '{', 'sample', 'x'
[17:28:22.296] Searching for globals ... DONE
[17:28:22.296] Resolving globals: FALSE
[17:28:22.297] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:22.297] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:22.298] - globals: [1] 'x'
[17:28:22.298] 
[17:28:22.298] getGlobalsAndPackages() ... DONE
[17:28:22.298] run() for 'Future' ...
[17:28:22.298] - state: 'created'
[17:28:22.299] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:22.313] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:22.313] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:22.313]   - Field: 'node'
[17:28:22.313]   - Field: 'label'
[17:28:22.314]   - Field: 'local'
[17:28:22.314]   - Field: 'owner'
[17:28:22.314]   - Field: 'envir'
[17:28:22.314]   - Field: 'workers'
[17:28:22.314]   - Field: 'packages'
[17:28:22.315]   - Field: 'gc'
[17:28:22.315]   - Field: 'conditions'
[17:28:22.315]   - Field: 'persistent'
[17:28:22.315]   - Field: 'expr'
[17:28:22.315]   - Field: 'uuid'
[17:28:22.315]   - Field: 'seed'
[17:28:22.316]   - Field: 'version'
[17:28:22.316]   - Field: 'result'
[17:28:22.316]   - Field: 'asynchronous'
[17:28:22.316]   - Field: 'calls'
[17:28:22.316]   - Field: 'globals'
[17:28:22.316]   - Field: 'stdout'
[17:28:22.317]   - Field: 'earlySignal'
[17:28:22.317]   - Field: 'lazy'
[17:28:22.317]   - Field: 'state'
[17:28:22.317] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:22.317] - Launch lazy future ...
[17:28:22.318] Packages needed by the future expression (n = 0): <none>
[17:28:22.318] Packages needed by future strategies (n = 0): <none>
[17:28:22.318] {
[17:28:22.318]     {
[17:28:22.318]         {
[17:28:22.318]             ...future.startTime <- base::Sys.time()
[17:28:22.318]             {
[17:28:22.318]                 {
[17:28:22.318]                   {
[17:28:22.318]                     {
[17:28:22.318]                       base::local({
[17:28:22.318]                         has_future <- base::requireNamespace("future", 
[17:28:22.318]                           quietly = TRUE)
[17:28:22.318]                         if (has_future) {
[17:28:22.318]                           ns <- base::getNamespace("future")
[17:28:22.318]                           version <- ns[[".package"]][["version"]]
[17:28:22.318]                           if (is.null(version)) 
[17:28:22.318]                             version <- utils::packageVersion("future")
[17:28:22.318]                         }
[17:28:22.318]                         else {
[17:28:22.318]                           version <- NULL
[17:28:22.318]                         }
[17:28:22.318]                         if (!has_future || version < "1.8.0") {
[17:28:22.318]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:22.318]                             "", base::R.version$version.string), 
[17:28:22.318]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:22.318]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:22.318]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:22.318]                               "release", "version")], collapse = " "), 
[17:28:22.318]                             hostname = base::Sys.info()[["nodename"]])
[17:28:22.318]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:22.318]                             info)
[17:28:22.318]                           info <- base::paste(info, collapse = "; ")
[17:28:22.318]                           if (!has_future) {
[17:28:22.318]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:22.318]                               info)
[17:28:22.318]                           }
[17:28:22.318]                           else {
[17:28:22.318]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:22.318]                               info, version)
[17:28:22.318]                           }
[17:28:22.318]                           base::stop(msg)
[17:28:22.318]                         }
[17:28:22.318]                       })
[17:28:22.318]                     }
[17:28:22.318]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:22.318]                     base::options(mc.cores = 1L)
[17:28:22.318]                   }
[17:28:22.318]                   ...future.strategy.old <- future::plan("list")
[17:28:22.318]                   options(future.plan = NULL)
[17:28:22.318]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.318]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:22.318]                 }
[17:28:22.318]                 ...future.workdir <- getwd()
[17:28:22.318]             }
[17:28:22.318]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:22.318]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:22.318]         }
[17:28:22.318]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:22.318]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:22.318]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:22.318]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:22.318]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:22.318]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:22.318]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:22.318]             base::names(...future.oldOptions))
[17:28:22.318]     }
[17:28:22.318]     if (FALSE) {
[17:28:22.318]     }
[17:28:22.318]     else {
[17:28:22.318]         if (TRUE) {
[17:28:22.318]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:22.318]                 open = "w")
[17:28:22.318]         }
[17:28:22.318]         else {
[17:28:22.318]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:22.318]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:22.318]         }
[17:28:22.318]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:22.318]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:22.318]             base::sink(type = "output", split = FALSE)
[17:28:22.318]             base::close(...future.stdout)
[17:28:22.318]         }, add = TRUE)
[17:28:22.318]     }
[17:28:22.318]     ...future.frame <- base::sys.nframe()
[17:28:22.318]     ...future.conditions <- base::list()
[17:28:22.318]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:22.318]     if (FALSE) {
[17:28:22.318]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:22.318]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:22.318]     }
[17:28:22.318]     ...future.result <- base::tryCatch({
[17:28:22.318]         base::withCallingHandlers({
[17:28:22.318]             ...future.value <- base::withVisible(base::local({
[17:28:22.318]                 ...future.makeSendCondition <- base::local({
[17:28:22.318]                   sendCondition <- NULL
[17:28:22.318]                   function(frame = 1L) {
[17:28:22.318]                     if (is.function(sendCondition)) 
[17:28:22.318]                       return(sendCondition)
[17:28:22.318]                     ns <- getNamespace("parallel")
[17:28:22.318]                     if (exists("sendData", mode = "function", 
[17:28:22.318]                       envir = ns)) {
[17:28:22.318]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:22.318]                         envir = ns)
[17:28:22.318]                       envir <- sys.frame(frame)
[17:28:22.318]                       master <- NULL
[17:28:22.318]                       while (!identical(envir, .GlobalEnv) && 
[17:28:22.318]                         !identical(envir, emptyenv())) {
[17:28:22.318]                         if (exists("master", mode = "list", envir = envir, 
[17:28:22.318]                           inherits = FALSE)) {
[17:28:22.318]                           master <- get("master", mode = "list", 
[17:28:22.318]                             envir = envir, inherits = FALSE)
[17:28:22.318]                           if (inherits(master, c("SOCKnode", 
[17:28:22.318]                             "SOCK0node"))) {
[17:28:22.318]                             sendCondition <<- function(cond) {
[17:28:22.318]                               data <- list(type = "VALUE", value = cond, 
[17:28:22.318]                                 success = TRUE)
[17:28:22.318]                               parallel_sendData(master, data)
[17:28:22.318]                             }
[17:28:22.318]                             return(sendCondition)
[17:28:22.318]                           }
[17:28:22.318]                         }
[17:28:22.318]                         frame <- frame + 1L
[17:28:22.318]                         envir <- sys.frame(frame)
[17:28:22.318]                       }
[17:28:22.318]                     }
[17:28:22.318]                     sendCondition <<- function(cond) NULL
[17:28:22.318]                   }
[17:28:22.318]                 })
[17:28:22.318]                 withCallingHandlers({
[17:28:22.318]                   {
[17:28:22.318]                     sample(x, size = 1L)
[17:28:22.318]                   }
[17:28:22.318]                 }, immediateCondition = function(cond) {
[17:28:22.318]                   sendCondition <- ...future.makeSendCondition()
[17:28:22.318]                   sendCondition(cond)
[17:28:22.318]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.318]                   {
[17:28:22.318]                     inherits <- base::inherits
[17:28:22.318]                     invokeRestart <- base::invokeRestart
[17:28:22.318]                     is.null <- base::is.null
[17:28:22.318]                     muffled <- FALSE
[17:28:22.318]                     if (inherits(cond, "message")) {
[17:28:22.318]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:22.318]                       if (muffled) 
[17:28:22.318]                         invokeRestart("muffleMessage")
[17:28:22.318]                     }
[17:28:22.318]                     else if (inherits(cond, "warning")) {
[17:28:22.318]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:22.318]                       if (muffled) 
[17:28:22.318]                         invokeRestart("muffleWarning")
[17:28:22.318]                     }
[17:28:22.318]                     else if (inherits(cond, "condition")) {
[17:28:22.318]                       if (!is.null(pattern)) {
[17:28:22.318]                         computeRestarts <- base::computeRestarts
[17:28:22.318]                         grepl <- base::grepl
[17:28:22.318]                         restarts <- computeRestarts(cond)
[17:28:22.318]                         for (restart in restarts) {
[17:28:22.318]                           name <- restart$name
[17:28:22.318]                           if (is.null(name)) 
[17:28:22.318]                             next
[17:28:22.318]                           if (!grepl(pattern, name)) 
[17:28:22.318]                             next
[17:28:22.318]                           invokeRestart(restart)
[17:28:22.318]                           muffled <- TRUE
[17:28:22.318]                           break
[17:28:22.318]                         }
[17:28:22.318]                       }
[17:28:22.318]                     }
[17:28:22.318]                     invisible(muffled)
[17:28:22.318]                   }
[17:28:22.318]                   muffleCondition(cond)
[17:28:22.318]                 })
[17:28:22.318]             }))
[17:28:22.318]             future::FutureResult(value = ...future.value$value, 
[17:28:22.318]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.318]                   ...future.rng), globalenv = if (FALSE) 
[17:28:22.318]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:22.318]                     ...future.globalenv.names))
[17:28:22.318]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:22.318]         }, condition = base::local({
[17:28:22.318]             c <- base::c
[17:28:22.318]             inherits <- base::inherits
[17:28:22.318]             invokeRestart <- base::invokeRestart
[17:28:22.318]             length <- base::length
[17:28:22.318]             list <- base::list
[17:28:22.318]             seq.int <- base::seq.int
[17:28:22.318]             signalCondition <- base::signalCondition
[17:28:22.318]             sys.calls <- base::sys.calls
[17:28:22.318]             `[[` <- base::`[[`
[17:28:22.318]             `+` <- base::`+`
[17:28:22.318]             `<<-` <- base::`<<-`
[17:28:22.318]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:22.318]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:22.318]                   3L)]
[17:28:22.318]             }
[17:28:22.318]             function(cond) {
[17:28:22.318]                 is_error <- inherits(cond, "error")
[17:28:22.318]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:22.318]                   NULL)
[17:28:22.318]                 if (is_error) {
[17:28:22.318]                   sessionInformation <- function() {
[17:28:22.318]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:22.318]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:22.318]                       search = base::search(), system = base::Sys.info())
[17:28:22.318]                   }
[17:28:22.318]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.318]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:22.318]                     cond$call), session = sessionInformation(), 
[17:28:22.318]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:22.318]                   signalCondition(cond)
[17:28:22.318]                 }
[17:28:22.318]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:22.318]                 "immediateCondition"))) {
[17:28:22.318]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:22.318]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.318]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:22.318]                   if (TRUE && !signal) {
[17:28:22.318]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.318]                     {
[17:28:22.318]                       inherits <- base::inherits
[17:28:22.318]                       invokeRestart <- base::invokeRestart
[17:28:22.318]                       is.null <- base::is.null
[17:28:22.318]                       muffled <- FALSE
[17:28:22.318]                       if (inherits(cond, "message")) {
[17:28:22.318]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.318]                         if (muffled) 
[17:28:22.318]                           invokeRestart("muffleMessage")
[17:28:22.318]                       }
[17:28:22.318]                       else if (inherits(cond, "warning")) {
[17:28:22.318]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.318]                         if (muffled) 
[17:28:22.318]                           invokeRestart("muffleWarning")
[17:28:22.318]                       }
[17:28:22.318]                       else if (inherits(cond, "condition")) {
[17:28:22.318]                         if (!is.null(pattern)) {
[17:28:22.318]                           computeRestarts <- base::computeRestarts
[17:28:22.318]                           grepl <- base::grepl
[17:28:22.318]                           restarts <- computeRestarts(cond)
[17:28:22.318]                           for (restart in restarts) {
[17:28:22.318]                             name <- restart$name
[17:28:22.318]                             if (is.null(name)) 
[17:28:22.318]                               next
[17:28:22.318]                             if (!grepl(pattern, name)) 
[17:28:22.318]                               next
[17:28:22.318]                             invokeRestart(restart)
[17:28:22.318]                             muffled <- TRUE
[17:28:22.318]                             break
[17:28:22.318]                           }
[17:28:22.318]                         }
[17:28:22.318]                       }
[17:28:22.318]                       invisible(muffled)
[17:28:22.318]                     }
[17:28:22.318]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.318]                   }
[17:28:22.318]                 }
[17:28:22.318]                 else {
[17:28:22.318]                   if (TRUE) {
[17:28:22.318]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.318]                     {
[17:28:22.318]                       inherits <- base::inherits
[17:28:22.318]                       invokeRestart <- base::invokeRestart
[17:28:22.318]                       is.null <- base::is.null
[17:28:22.318]                       muffled <- FALSE
[17:28:22.318]                       if (inherits(cond, "message")) {
[17:28:22.318]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.318]                         if (muffled) 
[17:28:22.318]                           invokeRestart("muffleMessage")
[17:28:22.318]                       }
[17:28:22.318]                       else if (inherits(cond, "warning")) {
[17:28:22.318]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.318]                         if (muffled) 
[17:28:22.318]                           invokeRestart("muffleWarning")
[17:28:22.318]                       }
[17:28:22.318]                       else if (inherits(cond, "condition")) {
[17:28:22.318]                         if (!is.null(pattern)) {
[17:28:22.318]                           computeRestarts <- base::computeRestarts
[17:28:22.318]                           grepl <- base::grepl
[17:28:22.318]                           restarts <- computeRestarts(cond)
[17:28:22.318]                           for (restart in restarts) {
[17:28:22.318]                             name <- restart$name
[17:28:22.318]                             if (is.null(name)) 
[17:28:22.318]                               next
[17:28:22.318]                             if (!grepl(pattern, name)) 
[17:28:22.318]                               next
[17:28:22.318]                             invokeRestart(restart)
[17:28:22.318]                             muffled <- TRUE
[17:28:22.318]                             break
[17:28:22.318]                           }
[17:28:22.318]                         }
[17:28:22.318]                       }
[17:28:22.318]                       invisible(muffled)
[17:28:22.318]                     }
[17:28:22.318]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.318]                   }
[17:28:22.318]                 }
[17:28:22.318]             }
[17:28:22.318]         }))
[17:28:22.318]     }, error = function(ex) {
[17:28:22.318]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:22.318]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.318]                 ...future.rng), started = ...future.startTime, 
[17:28:22.318]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:22.318]             version = "1.8"), class = "FutureResult")
[17:28:22.318]     }, finally = {
[17:28:22.318]         if (!identical(...future.workdir, getwd())) 
[17:28:22.318]             setwd(...future.workdir)
[17:28:22.318]         {
[17:28:22.318]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:22.318]                 ...future.oldOptions$nwarnings <- NULL
[17:28:22.318]             }
[17:28:22.318]             base::options(...future.oldOptions)
[17:28:22.318]             if (.Platform$OS.type == "windows") {
[17:28:22.318]                 old_names <- names(...future.oldEnvVars)
[17:28:22.318]                 envs <- base::Sys.getenv()
[17:28:22.318]                 names <- names(envs)
[17:28:22.318]                 common <- intersect(names, old_names)
[17:28:22.318]                 added <- setdiff(names, old_names)
[17:28:22.318]                 removed <- setdiff(old_names, names)
[17:28:22.318]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:22.318]                   envs[common]]
[17:28:22.318]                 NAMES <- toupper(changed)
[17:28:22.318]                 args <- list()
[17:28:22.318]                 for (kk in seq_along(NAMES)) {
[17:28:22.318]                   name <- changed[[kk]]
[17:28:22.318]                   NAME <- NAMES[[kk]]
[17:28:22.318]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.318]                     next
[17:28:22.318]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.318]                 }
[17:28:22.318]                 NAMES <- toupper(added)
[17:28:22.318]                 for (kk in seq_along(NAMES)) {
[17:28:22.318]                   name <- added[[kk]]
[17:28:22.318]                   NAME <- NAMES[[kk]]
[17:28:22.318]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.318]                     next
[17:28:22.318]                   args[[name]] <- ""
[17:28:22.318]                 }
[17:28:22.318]                 NAMES <- toupper(removed)
[17:28:22.318]                 for (kk in seq_along(NAMES)) {
[17:28:22.318]                   name <- removed[[kk]]
[17:28:22.318]                   NAME <- NAMES[[kk]]
[17:28:22.318]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.318]                     next
[17:28:22.318]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.318]                 }
[17:28:22.318]                 if (length(args) > 0) 
[17:28:22.318]                   base::do.call(base::Sys.setenv, args = args)
[17:28:22.318]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:22.318]             }
[17:28:22.318]             else {
[17:28:22.318]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:22.318]             }
[17:28:22.318]             {
[17:28:22.318]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:22.318]                   0L) {
[17:28:22.318]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:22.318]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:22.318]                   base::options(opts)
[17:28:22.318]                 }
[17:28:22.318]                 {
[17:28:22.318]                   {
[17:28:22.318]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:22.318]                     NULL
[17:28:22.318]                   }
[17:28:22.318]                   options(future.plan = NULL)
[17:28:22.318]                   if (is.na(NA_character_)) 
[17:28:22.318]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.318]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:22.318]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:22.318]                     .init = FALSE)
[17:28:22.318]                 }
[17:28:22.318]             }
[17:28:22.318]         }
[17:28:22.318]     })
[17:28:22.318]     if (TRUE) {
[17:28:22.318]         base::sink(type = "output", split = FALSE)
[17:28:22.318]         if (TRUE) {
[17:28:22.318]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:22.318]         }
[17:28:22.318]         else {
[17:28:22.318]             ...future.result["stdout"] <- base::list(NULL)
[17:28:22.318]         }
[17:28:22.318]         base::close(...future.stdout)
[17:28:22.318]         ...future.stdout <- NULL
[17:28:22.318]     }
[17:28:22.318]     ...future.result$conditions <- ...future.conditions
[17:28:22.318]     ...future.result$finished <- base::Sys.time()
[17:28:22.318]     ...future.result
[17:28:22.318] }
[17:28:22.323] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:22.336] receiveMessageFromWorker() for ClusterFuture ...
[17:28:22.336] - Validating connection of MultisessionFuture
[17:28:22.336] - received message: FutureResult
[17:28:22.336] - Received FutureResult
[17:28:22.337] - Erased future from FutureRegistry
[17:28:22.337] result() for ClusterFuture ...
[17:28:22.337] - result already collected: FutureResult
[17:28:22.337] result() for ClusterFuture ... done
[17:28:22.337] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:22.337] result() for ClusterFuture ...
[17:28:22.338] - result already collected: FutureResult
[17:28:22.338] result() for ClusterFuture ... done
[17:28:22.338] result() for ClusterFuture ...
[17:28:22.338] - result already collected: FutureResult
[17:28:22.338] result() for ClusterFuture ... done
[17:28:22.339] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:22.339] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:22.340] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:22.340] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:22.340] MultisessionFuture started
[17:28:22.341] - Launch lazy future ... done
[17:28:22.341] run() for 'MultisessionFuture' ... done
[17:28:22.341] getGlobalsAndPackages() ...
[17:28:22.342] Searching for globals...
[17:28:22.343] - globals found: [3] '{', 'sample', 'x'
[17:28:22.343] Searching for globals ... DONE
[17:28:22.343] Resolving globals: FALSE
[17:28:22.344] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:22.344] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:22.344] - globals: [1] 'x'
[17:28:22.344] 
[17:28:22.345] getGlobalsAndPackages() ... DONE
[17:28:22.345] run() for 'Future' ...
[17:28:22.345] - state: 'created'
[17:28:22.345] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:22.359] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:22.359] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:22.359]   - Field: 'node'
[17:28:22.360]   - Field: 'label'
[17:28:22.360]   - Field: 'local'
[17:28:22.360]   - Field: 'owner'
[17:28:22.360]   - Field: 'envir'
[17:28:22.360]   - Field: 'workers'
[17:28:22.361]   - Field: 'packages'
[17:28:22.361]   - Field: 'gc'
[17:28:22.361]   - Field: 'conditions'
[17:28:22.361]   - Field: 'persistent'
[17:28:22.361]   - Field: 'expr'
[17:28:22.361]   - Field: 'uuid'
[17:28:22.362]   - Field: 'seed'
[17:28:22.362]   - Field: 'version'
[17:28:22.362]   - Field: 'result'
[17:28:22.362]   - Field: 'asynchronous'
[17:28:22.362]   - Field: 'calls'
[17:28:22.362]   - Field: 'globals'
[17:28:22.363]   - Field: 'stdout'
[17:28:22.363]   - Field: 'earlySignal'
[17:28:22.363]   - Field: 'lazy'
[17:28:22.363]   - Field: 'state'
[17:28:22.363] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:22.363] - Launch lazy future ...
[17:28:22.364] Packages needed by the future expression (n = 0): <none>
[17:28:22.364] Packages needed by future strategies (n = 0): <none>
[17:28:22.365] {
[17:28:22.365]     {
[17:28:22.365]         {
[17:28:22.365]             ...future.startTime <- base::Sys.time()
[17:28:22.365]             {
[17:28:22.365]                 {
[17:28:22.365]                   {
[17:28:22.365]                     {
[17:28:22.365]                       base::local({
[17:28:22.365]                         has_future <- base::requireNamespace("future", 
[17:28:22.365]                           quietly = TRUE)
[17:28:22.365]                         if (has_future) {
[17:28:22.365]                           ns <- base::getNamespace("future")
[17:28:22.365]                           version <- ns[[".package"]][["version"]]
[17:28:22.365]                           if (is.null(version)) 
[17:28:22.365]                             version <- utils::packageVersion("future")
[17:28:22.365]                         }
[17:28:22.365]                         else {
[17:28:22.365]                           version <- NULL
[17:28:22.365]                         }
[17:28:22.365]                         if (!has_future || version < "1.8.0") {
[17:28:22.365]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:22.365]                             "", base::R.version$version.string), 
[17:28:22.365]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:22.365]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:22.365]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:22.365]                               "release", "version")], collapse = " "), 
[17:28:22.365]                             hostname = base::Sys.info()[["nodename"]])
[17:28:22.365]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:22.365]                             info)
[17:28:22.365]                           info <- base::paste(info, collapse = "; ")
[17:28:22.365]                           if (!has_future) {
[17:28:22.365]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:22.365]                               info)
[17:28:22.365]                           }
[17:28:22.365]                           else {
[17:28:22.365]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:22.365]                               info, version)
[17:28:22.365]                           }
[17:28:22.365]                           base::stop(msg)
[17:28:22.365]                         }
[17:28:22.365]                       })
[17:28:22.365]                     }
[17:28:22.365]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:22.365]                     base::options(mc.cores = 1L)
[17:28:22.365]                   }
[17:28:22.365]                   ...future.strategy.old <- future::plan("list")
[17:28:22.365]                   options(future.plan = NULL)
[17:28:22.365]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.365]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:22.365]                 }
[17:28:22.365]                 ...future.workdir <- getwd()
[17:28:22.365]             }
[17:28:22.365]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:22.365]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:22.365]         }
[17:28:22.365]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:22.365]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:22.365]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:22.365]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:22.365]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:22.365]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:22.365]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:22.365]             base::names(...future.oldOptions))
[17:28:22.365]     }
[17:28:22.365]     if (FALSE) {
[17:28:22.365]     }
[17:28:22.365]     else {
[17:28:22.365]         if (TRUE) {
[17:28:22.365]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:22.365]                 open = "w")
[17:28:22.365]         }
[17:28:22.365]         else {
[17:28:22.365]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:22.365]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:22.365]         }
[17:28:22.365]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:22.365]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:22.365]             base::sink(type = "output", split = FALSE)
[17:28:22.365]             base::close(...future.stdout)
[17:28:22.365]         }, add = TRUE)
[17:28:22.365]     }
[17:28:22.365]     ...future.frame <- base::sys.nframe()
[17:28:22.365]     ...future.conditions <- base::list()
[17:28:22.365]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:22.365]     if (FALSE) {
[17:28:22.365]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:22.365]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:22.365]     }
[17:28:22.365]     ...future.result <- base::tryCatch({
[17:28:22.365]         base::withCallingHandlers({
[17:28:22.365]             ...future.value <- base::withVisible(base::local({
[17:28:22.365]                 ...future.makeSendCondition <- base::local({
[17:28:22.365]                   sendCondition <- NULL
[17:28:22.365]                   function(frame = 1L) {
[17:28:22.365]                     if (is.function(sendCondition)) 
[17:28:22.365]                       return(sendCondition)
[17:28:22.365]                     ns <- getNamespace("parallel")
[17:28:22.365]                     if (exists("sendData", mode = "function", 
[17:28:22.365]                       envir = ns)) {
[17:28:22.365]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:22.365]                         envir = ns)
[17:28:22.365]                       envir <- sys.frame(frame)
[17:28:22.365]                       master <- NULL
[17:28:22.365]                       while (!identical(envir, .GlobalEnv) && 
[17:28:22.365]                         !identical(envir, emptyenv())) {
[17:28:22.365]                         if (exists("master", mode = "list", envir = envir, 
[17:28:22.365]                           inherits = FALSE)) {
[17:28:22.365]                           master <- get("master", mode = "list", 
[17:28:22.365]                             envir = envir, inherits = FALSE)
[17:28:22.365]                           if (inherits(master, c("SOCKnode", 
[17:28:22.365]                             "SOCK0node"))) {
[17:28:22.365]                             sendCondition <<- function(cond) {
[17:28:22.365]                               data <- list(type = "VALUE", value = cond, 
[17:28:22.365]                                 success = TRUE)
[17:28:22.365]                               parallel_sendData(master, data)
[17:28:22.365]                             }
[17:28:22.365]                             return(sendCondition)
[17:28:22.365]                           }
[17:28:22.365]                         }
[17:28:22.365]                         frame <- frame + 1L
[17:28:22.365]                         envir <- sys.frame(frame)
[17:28:22.365]                       }
[17:28:22.365]                     }
[17:28:22.365]                     sendCondition <<- function(cond) NULL
[17:28:22.365]                   }
[17:28:22.365]                 })
[17:28:22.365]                 withCallingHandlers({
[17:28:22.365]                   {
[17:28:22.365]                     sample(x, size = 1L)
[17:28:22.365]                   }
[17:28:22.365]                 }, immediateCondition = function(cond) {
[17:28:22.365]                   sendCondition <- ...future.makeSendCondition()
[17:28:22.365]                   sendCondition(cond)
[17:28:22.365]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.365]                   {
[17:28:22.365]                     inherits <- base::inherits
[17:28:22.365]                     invokeRestart <- base::invokeRestart
[17:28:22.365]                     is.null <- base::is.null
[17:28:22.365]                     muffled <- FALSE
[17:28:22.365]                     if (inherits(cond, "message")) {
[17:28:22.365]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:22.365]                       if (muffled) 
[17:28:22.365]                         invokeRestart("muffleMessage")
[17:28:22.365]                     }
[17:28:22.365]                     else if (inherits(cond, "warning")) {
[17:28:22.365]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:22.365]                       if (muffled) 
[17:28:22.365]                         invokeRestart("muffleWarning")
[17:28:22.365]                     }
[17:28:22.365]                     else if (inherits(cond, "condition")) {
[17:28:22.365]                       if (!is.null(pattern)) {
[17:28:22.365]                         computeRestarts <- base::computeRestarts
[17:28:22.365]                         grepl <- base::grepl
[17:28:22.365]                         restarts <- computeRestarts(cond)
[17:28:22.365]                         for (restart in restarts) {
[17:28:22.365]                           name <- restart$name
[17:28:22.365]                           if (is.null(name)) 
[17:28:22.365]                             next
[17:28:22.365]                           if (!grepl(pattern, name)) 
[17:28:22.365]                             next
[17:28:22.365]                           invokeRestart(restart)
[17:28:22.365]                           muffled <- TRUE
[17:28:22.365]                           break
[17:28:22.365]                         }
[17:28:22.365]                       }
[17:28:22.365]                     }
[17:28:22.365]                     invisible(muffled)
[17:28:22.365]                   }
[17:28:22.365]                   muffleCondition(cond)
[17:28:22.365]                 })
[17:28:22.365]             }))
[17:28:22.365]             future::FutureResult(value = ...future.value$value, 
[17:28:22.365]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.365]                   ...future.rng), globalenv = if (FALSE) 
[17:28:22.365]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:22.365]                     ...future.globalenv.names))
[17:28:22.365]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:22.365]         }, condition = base::local({
[17:28:22.365]             c <- base::c
[17:28:22.365]             inherits <- base::inherits
[17:28:22.365]             invokeRestart <- base::invokeRestart
[17:28:22.365]             length <- base::length
[17:28:22.365]             list <- base::list
[17:28:22.365]             seq.int <- base::seq.int
[17:28:22.365]             signalCondition <- base::signalCondition
[17:28:22.365]             sys.calls <- base::sys.calls
[17:28:22.365]             `[[` <- base::`[[`
[17:28:22.365]             `+` <- base::`+`
[17:28:22.365]             `<<-` <- base::`<<-`
[17:28:22.365]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:22.365]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:22.365]                   3L)]
[17:28:22.365]             }
[17:28:22.365]             function(cond) {
[17:28:22.365]                 is_error <- inherits(cond, "error")
[17:28:22.365]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:22.365]                   NULL)
[17:28:22.365]                 if (is_error) {
[17:28:22.365]                   sessionInformation <- function() {
[17:28:22.365]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:22.365]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:22.365]                       search = base::search(), system = base::Sys.info())
[17:28:22.365]                   }
[17:28:22.365]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.365]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:22.365]                     cond$call), session = sessionInformation(), 
[17:28:22.365]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:22.365]                   signalCondition(cond)
[17:28:22.365]                 }
[17:28:22.365]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:22.365]                 "immediateCondition"))) {
[17:28:22.365]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:22.365]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.365]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:22.365]                   if (TRUE && !signal) {
[17:28:22.365]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.365]                     {
[17:28:22.365]                       inherits <- base::inherits
[17:28:22.365]                       invokeRestart <- base::invokeRestart
[17:28:22.365]                       is.null <- base::is.null
[17:28:22.365]                       muffled <- FALSE
[17:28:22.365]                       if (inherits(cond, "message")) {
[17:28:22.365]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.365]                         if (muffled) 
[17:28:22.365]                           invokeRestart("muffleMessage")
[17:28:22.365]                       }
[17:28:22.365]                       else if (inherits(cond, "warning")) {
[17:28:22.365]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.365]                         if (muffled) 
[17:28:22.365]                           invokeRestart("muffleWarning")
[17:28:22.365]                       }
[17:28:22.365]                       else if (inherits(cond, "condition")) {
[17:28:22.365]                         if (!is.null(pattern)) {
[17:28:22.365]                           computeRestarts <- base::computeRestarts
[17:28:22.365]                           grepl <- base::grepl
[17:28:22.365]                           restarts <- computeRestarts(cond)
[17:28:22.365]                           for (restart in restarts) {
[17:28:22.365]                             name <- restart$name
[17:28:22.365]                             if (is.null(name)) 
[17:28:22.365]                               next
[17:28:22.365]                             if (!grepl(pattern, name)) 
[17:28:22.365]                               next
[17:28:22.365]                             invokeRestart(restart)
[17:28:22.365]                             muffled <- TRUE
[17:28:22.365]                             break
[17:28:22.365]                           }
[17:28:22.365]                         }
[17:28:22.365]                       }
[17:28:22.365]                       invisible(muffled)
[17:28:22.365]                     }
[17:28:22.365]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.365]                   }
[17:28:22.365]                 }
[17:28:22.365]                 else {
[17:28:22.365]                   if (TRUE) {
[17:28:22.365]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.365]                     {
[17:28:22.365]                       inherits <- base::inherits
[17:28:22.365]                       invokeRestart <- base::invokeRestart
[17:28:22.365]                       is.null <- base::is.null
[17:28:22.365]                       muffled <- FALSE
[17:28:22.365]                       if (inherits(cond, "message")) {
[17:28:22.365]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.365]                         if (muffled) 
[17:28:22.365]                           invokeRestart("muffleMessage")
[17:28:22.365]                       }
[17:28:22.365]                       else if (inherits(cond, "warning")) {
[17:28:22.365]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.365]                         if (muffled) 
[17:28:22.365]                           invokeRestart("muffleWarning")
[17:28:22.365]                       }
[17:28:22.365]                       else if (inherits(cond, "condition")) {
[17:28:22.365]                         if (!is.null(pattern)) {
[17:28:22.365]                           computeRestarts <- base::computeRestarts
[17:28:22.365]                           grepl <- base::grepl
[17:28:22.365]                           restarts <- computeRestarts(cond)
[17:28:22.365]                           for (restart in restarts) {
[17:28:22.365]                             name <- restart$name
[17:28:22.365]                             if (is.null(name)) 
[17:28:22.365]                               next
[17:28:22.365]                             if (!grepl(pattern, name)) 
[17:28:22.365]                               next
[17:28:22.365]                             invokeRestart(restart)
[17:28:22.365]                             muffled <- TRUE
[17:28:22.365]                             break
[17:28:22.365]                           }
[17:28:22.365]                         }
[17:28:22.365]                       }
[17:28:22.365]                       invisible(muffled)
[17:28:22.365]                     }
[17:28:22.365]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.365]                   }
[17:28:22.365]                 }
[17:28:22.365]             }
[17:28:22.365]         }))
[17:28:22.365]     }, error = function(ex) {
[17:28:22.365]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:22.365]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.365]                 ...future.rng), started = ...future.startTime, 
[17:28:22.365]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:22.365]             version = "1.8"), class = "FutureResult")
[17:28:22.365]     }, finally = {
[17:28:22.365]         if (!identical(...future.workdir, getwd())) 
[17:28:22.365]             setwd(...future.workdir)
[17:28:22.365]         {
[17:28:22.365]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:22.365]                 ...future.oldOptions$nwarnings <- NULL
[17:28:22.365]             }
[17:28:22.365]             base::options(...future.oldOptions)
[17:28:22.365]             if (.Platform$OS.type == "windows") {
[17:28:22.365]                 old_names <- names(...future.oldEnvVars)
[17:28:22.365]                 envs <- base::Sys.getenv()
[17:28:22.365]                 names <- names(envs)
[17:28:22.365]                 common <- intersect(names, old_names)
[17:28:22.365]                 added <- setdiff(names, old_names)
[17:28:22.365]                 removed <- setdiff(old_names, names)
[17:28:22.365]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:22.365]                   envs[common]]
[17:28:22.365]                 NAMES <- toupper(changed)
[17:28:22.365]                 args <- list()
[17:28:22.365]                 for (kk in seq_along(NAMES)) {
[17:28:22.365]                   name <- changed[[kk]]
[17:28:22.365]                   NAME <- NAMES[[kk]]
[17:28:22.365]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.365]                     next
[17:28:22.365]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.365]                 }
[17:28:22.365]                 NAMES <- toupper(added)
[17:28:22.365]                 for (kk in seq_along(NAMES)) {
[17:28:22.365]                   name <- added[[kk]]
[17:28:22.365]                   NAME <- NAMES[[kk]]
[17:28:22.365]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.365]                     next
[17:28:22.365]                   args[[name]] <- ""
[17:28:22.365]                 }
[17:28:22.365]                 NAMES <- toupper(removed)
[17:28:22.365]                 for (kk in seq_along(NAMES)) {
[17:28:22.365]                   name <- removed[[kk]]
[17:28:22.365]                   NAME <- NAMES[[kk]]
[17:28:22.365]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.365]                     next
[17:28:22.365]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.365]                 }
[17:28:22.365]                 if (length(args) > 0) 
[17:28:22.365]                   base::do.call(base::Sys.setenv, args = args)
[17:28:22.365]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:22.365]             }
[17:28:22.365]             else {
[17:28:22.365]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:22.365]             }
[17:28:22.365]             {
[17:28:22.365]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:22.365]                   0L) {
[17:28:22.365]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:22.365]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:22.365]                   base::options(opts)
[17:28:22.365]                 }
[17:28:22.365]                 {
[17:28:22.365]                   {
[17:28:22.365]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:22.365]                     NULL
[17:28:22.365]                   }
[17:28:22.365]                   options(future.plan = NULL)
[17:28:22.365]                   if (is.na(NA_character_)) 
[17:28:22.365]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.365]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:22.365]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:22.365]                     .init = FALSE)
[17:28:22.365]                 }
[17:28:22.365]             }
[17:28:22.365]         }
[17:28:22.365]     })
[17:28:22.365]     if (TRUE) {
[17:28:22.365]         base::sink(type = "output", split = FALSE)
[17:28:22.365]         if (TRUE) {
[17:28:22.365]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:22.365]         }
[17:28:22.365]         else {
[17:28:22.365]             ...future.result["stdout"] <- base::list(NULL)
[17:28:22.365]         }
[17:28:22.365]         base::close(...future.stdout)
[17:28:22.365]         ...future.stdout <- NULL
[17:28:22.365]     }
[17:28:22.365]     ...future.result$conditions <- ...future.conditions
[17:28:22.365]     ...future.result$finished <- base::Sys.time()
[17:28:22.365]     ...future.result
[17:28:22.365] }
[17:28:22.370] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:22.383] receiveMessageFromWorker() for ClusterFuture ...
[17:28:22.383] - Validating connection of MultisessionFuture
[17:28:22.383] - received message: FutureResult
[17:28:22.383] - Received FutureResult
[17:28:22.383] - Erased future from FutureRegistry
[17:28:22.384] result() for ClusterFuture ...
[17:28:22.384] - result already collected: FutureResult
[17:28:22.384] result() for ClusterFuture ... done
[17:28:22.384] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:22.384] result() for ClusterFuture ...
[17:28:22.384] - result already collected: FutureResult
[17:28:22.385] result() for ClusterFuture ... done
[17:28:22.385] result() for ClusterFuture ...
[17:28:22.385] - result already collected: FutureResult
[17:28:22.385] result() for ClusterFuture ... done
[17:28:22.386] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:22.386] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:22.387] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:22.387] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:22.388] MultisessionFuture started
[17:28:22.388] - Launch lazy future ... done
[17:28:22.388] run() for 'MultisessionFuture' ... done
[17:28:22.388] result() for ClusterFuture ...
[17:28:22.389] - result already collected: FutureResult
[17:28:22.389] result() for ClusterFuture ... done
[17:28:22.389] result() for ClusterFuture ...
[17:28:22.389] - result already collected: FutureResult
[17:28:22.389] result() for ClusterFuture ... done
[17:28:22.389] signalConditions() ...
[17:28:22.390]  - include = 'immediateCondition'
[17:28:22.390]  - exclude = 
[17:28:22.390]  - resignal = FALSE
[17:28:22.390]  - Number of conditions: 1
[17:28:22.390] signalConditions() ... done
[17:28:22.391] Future state: 'finished'
[17:28:22.391] result() for ClusterFuture ...
[17:28:22.391] - result already collected: FutureResult
[17:28:22.391] result() for ClusterFuture ... done
[17:28:22.391] signalConditions() ...
[17:28:22.391]  - include = 'condition'
[17:28:22.392]  - exclude = 'immediateCondition'
[17:28:22.392]  - resignal = TRUE
[17:28:22.392]  - Number of conditions: 1
[17:28:22.392]  - Condition #1: 'RngFutureError', 'FutureError', 'error', 'RngFutureCondition', 'FutureCondition', 'condition'
[17:28:22.392] signalConditions() ... done
<RngFutureError: UNRELIABLE VALUE: Future ('fsample_1-316434') 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: 5b3cb6c0-318f-d861-1306-95b7b056f4fd


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

DEBUG: END TROUBLESHOOTING HELP
[17:28:22.394] getGlobalsAndPackages() ...
[17:28:22.394] Searching for globals...
[17:28:22.395] - globals found: [3] '{', 'sample', 'x'
[17:28:22.395] Searching for globals ... DONE
[17:28:22.396] Resolving globals: FALSE
[17:28:22.396] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:22.396] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:22.397] - globals: [1] 'x'
[17:28:22.397] 
[17:28:22.397] getGlobalsAndPackages() ... DONE
[17:28:22.397] run() for 'Future' ...
[17:28:22.398] - state: 'created'
[17:28:22.398] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:22.411] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:22.411] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:22.412]   - Field: 'node'
[17:28:22.412]   - Field: 'label'
[17:28:22.412]   - Field: 'local'
[17:28:22.412]   - Field: 'owner'
[17:28:22.412]   - Field: 'envir'
[17:28:22.412]   - Field: 'workers'
[17:28:22.413]   - Field: 'packages'
[17:28:22.413]   - Field: 'gc'
[17:28:22.413]   - Field: 'conditions'
[17:28:22.413]   - Field: 'persistent'
[17:28:22.413]   - Field: 'expr'
[17:28:22.414]   - Field: 'uuid'
[17:28:22.414]   - Field: 'seed'
[17:28:22.414]   - Field: 'version'
[17:28:22.414]   - Field: 'result'
[17:28:22.414]   - Field: 'asynchronous'
[17:28:22.414]   - Field: 'calls'
[17:28:22.415]   - Field: 'globals'
[17:28:22.415]   - Field: 'stdout'
[17:28:22.415]   - Field: 'earlySignal'
[17:28:22.415]   - Field: 'lazy'
[17:28:22.415]   - Field: 'state'
[17:28:22.415] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:22.416] - Launch lazy future ...
[17:28:22.416] Packages needed by the future expression (n = 0): <none>
[17:28:22.416] Packages needed by future strategies (n = 0): <none>
[17:28:22.417] {
[17:28:22.417]     {
[17:28:22.417]         {
[17:28:22.417]             ...future.startTime <- base::Sys.time()
[17:28:22.417]             {
[17:28:22.417]                 {
[17:28:22.417]                   {
[17:28:22.417]                     {
[17:28:22.417]                       base::local({
[17:28:22.417]                         has_future <- base::requireNamespace("future", 
[17:28:22.417]                           quietly = TRUE)
[17:28:22.417]                         if (has_future) {
[17:28:22.417]                           ns <- base::getNamespace("future")
[17:28:22.417]                           version <- ns[[".package"]][["version"]]
[17:28:22.417]                           if (is.null(version)) 
[17:28:22.417]                             version <- utils::packageVersion("future")
[17:28:22.417]                         }
[17:28:22.417]                         else {
[17:28:22.417]                           version <- NULL
[17:28:22.417]                         }
[17:28:22.417]                         if (!has_future || version < "1.8.0") {
[17:28:22.417]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:22.417]                             "", base::R.version$version.string), 
[17:28:22.417]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:22.417]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:22.417]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:22.417]                               "release", "version")], collapse = " "), 
[17:28:22.417]                             hostname = base::Sys.info()[["nodename"]])
[17:28:22.417]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:22.417]                             info)
[17:28:22.417]                           info <- base::paste(info, collapse = "; ")
[17:28:22.417]                           if (!has_future) {
[17:28:22.417]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:22.417]                               info)
[17:28:22.417]                           }
[17:28:22.417]                           else {
[17:28:22.417]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:22.417]                               info, version)
[17:28:22.417]                           }
[17:28:22.417]                           base::stop(msg)
[17:28:22.417]                         }
[17:28:22.417]                       })
[17:28:22.417]                     }
[17:28:22.417]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:22.417]                     base::options(mc.cores = 1L)
[17:28:22.417]                   }
[17:28:22.417]                   ...future.strategy.old <- future::plan("list")
[17:28:22.417]                   options(future.plan = NULL)
[17:28:22.417]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.417]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:22.417]                 }
[17:28:22.417]                 ...future.workdir <- getwd()
[17:28:22.417]             }
[17:28:22.417]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:22.417]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:22.417]         }
[17:28:22.417]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:22.417]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:22.417]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:22.417]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:22.417]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:22.417]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:22.417]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:22.417]             base::names(...future.oldOptions))
[17:28:22.417]     }
[17:28:22.417]     if (FALSE) {
[17:28:22.417]     }
[17:28:22.417]     else {
[17:28:22.417]         if (TRUE) {
[17:28:22.417]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:22.417]                 open = "w")
[17:28:22.417]         }
[17:28:22.417]         else {
[17:28:22.417]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:22.417]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:22.417]         }
[17:28:22.417]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:22.417]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:22.417]             base::sink(type = "output", split = FALSE)
[17:28:22.417]             base::close(...future.stdout)
[17:28:22.417]         }, add = TRUE)
[17:28:22.417]     }
[17:28:22.417]     ...future.frame <- base::sys.nframe()
[17:28:22.417]     ...future.conditions <- base::list()
[17:28:22.417]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:22.417]     if (FALSE) {
[17:28:22.417]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:22.417]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:22.417]     }
[17:28:22.417]     ...future.result <- base::tryCatch({
[17:28:22.417]         base::withCallingHandlers({
[17:28:22.417]             ...future.value <- base::withVisible(base::local({
[17:28:22.417]                 ...future.makeSendCondition <- base::local({
[17:28:22.417]                   sendCondition <- NULL
[17:28:22.417]                   function(frame = 1L) {
[17:28:22.417]                     if (is.function(sendCondition)) 
[17:28:22.417]                       return(sendCondition)
[17:28:22.417]                     ns <- getNamespace("parallel")
[17:28:22.417]                     if (exists("sendData", mode = "function", 
[17:28:22.417]                       envir = ns)) {
[17:28:22.417]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:22.417]                         envir = ns)
[17:28:22.417]                       envir <- sys.frame(frame)
[17:28:22.417]                       master <- NULL
[17:28:22.417]                       while (!identical(envir, .GlobalEnv) && 
[17:28:22.417]                         !identical(envir, emptyenv())) {
[17:28:22.417]                         if (exists("master", mode = "list", envir = envir, 
[17:28:22.417]                           inherits = FALSE)) {
[17:28:22.417]                           master <- get("master", mode = "list", 
[17:28:22.417]                             envir = envir, inherits = FALSE)
[17:28:22.417]                           if (inherits(master, c("SOCKnode", 
[17:28:22.417]                             "SOCK0node"))) {
[17:28:22.417]                             sendCondition <<- function(cond) {
[17:28:22.417]                               data <- list(type = "VALUE", value = cond, 
[17:28:22.417]                                 success = TRUE)
[17:28:22.417]                               parallel_sendData(master, data)
[17:28:22.417]                             }
[17:28:22.417]                             return(sendCondition)
[17:28:22.417]                           }
[17:28:22.417]                         }
[17:28:22.417]                         frame <- frame + 1L
[17:28:22.417]                         envir <- sys.frame(frame)
[17:28:22.417]                       }
[17:28:22.417]                     }
[17:28:22.417]                     sendCondition <<- function(cond) NULL
[17:28:22.417]                   }
[17:28:22.417]                 })
[17:28:22.417]                 withCallingHandlers({
[17:28:22.417]                   {
[17:28:22.417]                     sample(x, size = 1L)
[17:28:22.417]                   }
[17:28:22.417]                 }, immediateCondition = function(cond) {
[17:28:22.417]                   sendCondition <- ...future.makeSendCondition()
[17:28:22.417]                   sendCondition(cond)
[17:28:22.417]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.417]                   {
[17:28:22.417]                     inherits <- base::inherits
[17:28:22.417]                     invokeRestart <- base::invokeRestart
[17:28:22.417]                     is.null <- base::is.null
[17:28:22.417]                     muffled <- FALSE
[17:28:22.417]                     if (inherits(cond, "message")) {
[17:28:22.417]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:22.417]                       if (muffled) 
[17:28:22.417]                         invokeRestart("muffleMessage")
[17:28:22.417]                     }
[17:28:22.417]                     else if (inherits(cond, "warning")) {
[17:28:22.417]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:22.417]                       if (muffled) 
[17:28:22.417]                         invokeRestart("muffleWarning")
[17:28:22.417]                     }
[17:28:22.417]                     else if (inherits(cond, "condition")) {
[17:28:22.417]                       if (!is.null(pattern)) {
[17:28:22.417]                         computeRestarts <- base::computeRestarts
[17:28:22.417]                         grepl <- base::grepl
[17:28:22.417]                         restarts <- computeRestarts(cond)
[17:28:22.417]                         for (restart in restarts) {
[17:28:22.417]                           name <- restart$name
[17:28:22.417]                           if (is.null(name)) 
[17:28:22.417]                             next
[17:28:22.417]                           if (!grepl(pattern, name)) 
[17:28:22.417]                             next
[17:28:22.417]                           invokeRestart(restart)
[17:28:22.417]                           muffled <- TRUE
[17:28:22.417]                           break
[17:28:22.417]                         }
[17:28:22.417]                       }
[17:28:22.417]                     }
[17:28:22.417]                     invisible(muffled)
[17:28:22.417]                   }
[17:28:22.417]                   muffleCondition(cond)
[17:28:22.417]                 })
[17:28:22.417]             }))
[17:28:22.417]             future::FutureResult(value = ...future.value$value, 
[17:28:22.417]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.417]                   ...future.rng), globalenv = if (FALSE) 
[17:28:22.417]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:22.417]                     ...future.globalenv.names))
[17:28:22.417]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:22.417]         }, condition = base::local({
[17:28:22.417]             c <- base::c
[17:28:22.417]             inherits <- base::inherits
[17:28:22.417]             invokeRestart <- base::invokeRestart
[17:28:22.417]             length <- base::length
[17:28:22.417]             list <- base::list
[17:28:22.417]             seq.int <- base::seq.int
[17:28:22.417]             signalCondition <- base::signalCondition
[17:28:22.417]             sys.calls <- base::sys.calls
[17:28:22.417]             `[[` <- base::`[[`
[17:28:22.417]             `+` <- base::`+`
[17:28:22.417]             `<<-` <- base::`<<-`
[17:28:22.417]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:22.417]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:22.417]                   3L)]
[17:28:22.417]             }
[17:28:22.417]             function(cond) {
[17:28:22.417]                 is_error <- inherits(cond, "error")
[17:28:22.417]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:22.417]                   NULL)
[17:28:22.417]                 if (is_error) {
[17:28:22.417]                   sessionInformation <- function() {
[17:28:22.417]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:22.417]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:22.417]                       search = base::search(), system = base::Sys.info())
[17:28:22.417]                   }
[17:28:22.417]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.417]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:22.417]                     cond$call), session = sessionInformation(), 
[17:28:22.417]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:22.417]                   signalCondition(cond)
[17:28:22.417]                 }
[17:28:22.417]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:22.417]                 "immediateCondition"))) {
[17:28:22.417]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:22.417]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.417]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:22.417]                   if (TRUE && !signal) {
[17:28:22.417]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.417]                     {
[17:28:22.417]                       inherits <- base::inherits
[17:28:22.417]                       invokeRestart <- base::invokeRestart
[17:28:22.417]                       is.null <- base::is.null
[17:28:22.417]                       muffled <- FALSE
[17:28:22.417]                       if (inherits(cond, "message")) {
[17:28:22.417]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.417]                         if (muffled) 
[17:28:22.417]                           invokeRestart("muffleMessage")
[17:28:22.417]                       }
[17:28:22.417]                       else if (inherits(cond, "warning")) {
[17:28:22.417]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.417]                         if (muffled) 
[17:28:22.417]                           invokeRestart("muffleWarning")
[17:28:22.417]                       }
[17:28:22.417]                       else if (inherits(cond, "condition")) {
[17:28:22.417]                         if (!is.null(pattern)) {
[17:28:22.417]                           computeRestarts <- base::computeRestarts
[17:28:22.417]                           grepl <- base::grepl
[17:28:22.417]                           restarts <- computeRestarts(cond)
[17:28:22.417]                           for (restart in restarts) {
[17:28:22.417]                             name <- restart$name
[17:28:22.417]                             if (is.null(name)) 
[17:28:22.417]                               next
[17:28:22.417]                             if (!grepl(pattern, name)) 
[17:28:22.417]                               next
[17:28:22.417]                             invokeRestart(restart)
[17:28:22.417]                             muffled <- TRUE
[17:28:22.417]                             break
[17:28:22.417]                           }
[17:28:22.417]                         }
[17:28:22.417]                       }
[17:28:22.417]                       invisible(muffled)
[17:28:22.417]                     }
[17:28:22.417]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.417]                   }
[17:28:22.417]                 }
[17:28:22.417]                 else {
[17:28:22.417]                   if (TRUE) {
[17:28:22.417]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.417]                     {
[17:28:22.417]                       inherits <- base::inherits
[17:28:22.417]                       invokeRestart <- base::invokeRestart
[17:28:22.417]                       is.null <- base::is.null
[17:28:22.417]                       muffled <- FALSE
[17:28:22.417]                       if (inherits(cond, "message")) {
[17:28:22.417]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.417]                         if (muffled) 
[17:28:22.417]                           invokeRestart("muffleMessage")
[17:28:22.417]                       }
[17:28:22.417]                       else if (inherits(cond, "warning")) {
[17:28:22.417]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.417]                         if (muffled) 
[17:28:22.417]                           invokeRestart("muffleWarning")
[17:28:22.417]                       }
[17:28:22.417]                       else if (inherits(cond, "condition")) {
[17:28:22.417]                         if (!is.null(pattern)) {
[17:28:22.417]                           computeRestarts <- base::computeRestarts
[17:28:22.417]                           grepl <- base::grepl
[17:28:22.417]                           restarts <- computeRestarts(cond)
[17:28:22.417]                           for (restart in restarts) {
[17:28:22.417]                             name <- restart$name
[17:28:22.417]                             if (is.null(name)) 
[17:28:22.417]                               next
[17:28:22.417]                             if (!grepl(pattern, name)) 
[17:28:22.417]                               next
[17:28:22.417]                             invokeRestart(restart)
[17:28:22.417]                             muffled <- TRUE
[17:28:22.417]                             break
[17:28:22.417]                           }
[17:28:22.417]                         }
[17:28:22.417]                       }
[17:28:22.417]                       invisible(muffled)
[17:28:22.417]                     }
[17:28:22.417]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.417]                   }
[17:28:22.417]                 }
[17:28:22.417]             }
[17:28:22.417]         }))
[17:28:22.417]     }, error = function(ex) {
[17:28:22.417]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:22.417]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.417]                 ...future.rng), started = ...future.startTime, 
[17:28:22.417]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:22.417]             version = "1.8"), class = "FutureResult")
[17:28:22.417]     }, finally = {
[17:28:22.417]         if (!identical(...future.workdir, getwd())) 
[17:28:22.417]             setwd(...future.workdir)
[17:28:22.417]         {
[17:28:22.417]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:22.417]                 ...future.oldOptions$nwarnings <- NULL
[17:28:22.417]             }
[17:28:22.417]             base::options(...future.oldOptions)
[17:28:22.417]             if (.Platform$OS.type == "windows") {
[17:28:22.417]                 old_names <- names(...future.oldEnvVars)
[17:28:22.417]                 envs <- base::Sys.getenv()
[17:28:22.417]                 names <- names(envs)
[17:28:22.417]                 common <- intersect(names, old_names)
[17:28:22.417]                 added <- setdiff(names, old_names)
[17:28:22.417]                 removed <- setdiff(old_names, names)
[17:28:22.417]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:22.417]                   envs[common]]
[17:28:22.417]                 NAMES <- toupper(changed)
[17:28:22.417]                 args <- list()
[17:28:22.417]                 for (kk in seq_along(NAMES)) {
[17:28:22.417]                   name <- changed[[kk]]
[17:28:22.417]                   NAME <- NAMES[[kk]]
[17:28:22.417]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.417]                     next
[17:28:22.417]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.417]                 }
[17:28:22.417]                 NAMES <- toupper(added)
[17:28:22.417]                 for (kk in seq_along(NAMES)) {
[17:28:22.417]                   name <- added[[kk]]
[17:28:22.417]                   NAME <- NAMES[[kk]]
[17:28:22.417]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.417]                     next
[17:28:22.417]                   args[[name]] <- ""
[17:28:22.417]                 }
[17:28:22.417]                 NAMES <- toupper(removed)
[17:28:22.417]                 for (kk in seq_along(NAMES)) {
[17:28:22.417]                   name <- removed[[kk]]
[17:28:22.417]                   NAME <- NAMES[[kk]]
[17:28:22.417]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.417]                     next
[17:28:22.417]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.417]                 }
[17:28:22.417]                 if (length(args) > 0) 
[17:28:22.417]                   base::do.call(base::Sys.setenv, args = args)
[17:28:22.417]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:22.417]             }
[17:28:22.417]             else {
[17:28:22.417]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:22.417]             }
[17:28:22.417]             {
[17:28:22.417]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:22.417]                   0L) {
[17:28:22.417]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:22.417]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:22.417]                   base::options(opts)
[17:28:22.417]                 }
[17:28:22.417]                 {
[17:28:22.417]                   {
[17:28:22.417]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:22.417]                     NULL
[17:28:22.417]                   }
[17:28:22.417]                   options(future.plan = NULL)
[17:28:22.417]                   if (is.na(NA_character_)) 
[17:28:22.417]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.417]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:22.417]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:22.417]                     .init = FALSE)
[17:28:22.417]                 }
[17:28:22.417]             }
[17:28:22.417]         }
[17:28:22.417]     })
[17:28:22.417]     if (TRUE) {
[17:28:22.417]         base::sink(type = "output", split = FALSE)
[17:28:22.417]         if (TRUE) {
[17:28:22.417]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:22.417]         }
[17:28:22.417]         else {
[17:28:22.417]             ...future.result["stdout"] <- base::list(NULL)
[17:28:22.417]         }
[17:28:22.417]         base::close(...future.stdout)
[17:28:22.417]         ...future.stdout <- NULL
[17:28:22.417]     }
[17:28:22.417]     ...future.result$conditions <- ...future.conditions
[17:28:22.417]     ...future.result$finished <- base::Sys.time()
[17:28:22.417]     ...future.result
[17:28:22.417] }
[17:28:22.421] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:22.445] receiveMessageFromWorker() for ClusterFuture ...
[17:28:22.445] - Validating connection of MultisessionFuture
[17:28:22.446] - received message: FutureResult
[17:28:22.446] - Received FutureResult
[17:28:22.446] - Erased future from FutureRegistry
[17:28:22.446] result() for ClusterFuture ...
[17:28:22.446] - result already collected: FutureResult
[17:28:22.446] result() for ClusterFuture ... done
[17:28:22.447] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:22.447] result() for ClusterFuture ...
[17:28:22.447] - result already collected: FutureResult
[17:28:22.447] result() for ClusterFuture ... done
[17:28:22.447] result() for ClusterFuture ...
[17:28:22.447] - result already collected: FutureResult
[17:28:22.448] result() for ClusterFuture ... done
[17:28:22.448] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:22.449] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:22.449] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:22.449] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:22.450] MultisessionFuture started
[17:28:22.450] - Launch lazy future ... done
[17:28:22.450] run() for 'MultisessionFuture' ... done
[17:28:22.451] getGlobalsAndPackages() ...
[17:28:22.451] Searching for globals...
[17:28:22.452] - globals found: [3] '{', 'sample', 'x'
[17:28:22.452] Searching for globals ... DONE
[17:28:22.453] Resolving globals: FALSE
[17:28:22.453] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:22.453] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:22.454] - globals: [1] 'x'
[17:28:22.454] 
[17:28:22.454] getGlobalsAndPackages() ... DONE
[17:28:22.454] run() for 'Future' ...
[17:28:22.454] - state: 'created'
[17:28:22.455] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:22.468] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:22.468] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:22.468]   - Field: 'node'
[17:28:22.469]   - Field: 'label'
[17:28:22.469]   - Field: 'local'
[17:28:22.469]   - Field: 'owner'
[17:28:22.469]   - Field: 'envir'
[17:28:22.469]   - Field: 'workers'
[17:28:22.470]   - Field: 'packages'
[17:28:22.470]   - Field: 'gc'
[17:28:22.470]   - Field: 'conditions'
[17:28:22.470]   - Field: 'persistent'
[17:28:22.470]   - Field: 'expr'
[17:28:22.470]   - Field: 'uuid'
[17:28:22.471]   - Field: 'seed'
[17:28:22.471]   - Field: 'version'
[17:28:22.471]   - Field: 'result'
[17:28:22.471]   - Field: 'asynchronous'
[17:28:22.471]   - Field: 'calls'
[17:28:22.471]   - Field: 'globals'
[17:28:22.472]   - Field: 'stdout'
[17:28:22.472]   - Field: 'earlySignal'
[17:28:22.472]   - Field: 'lazy'
[17:28:22.472]   - Field: 'state'
[17:28:22.472] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:22.473] - Launch lazy future ...
[17:28:22.473] Packages needed by the future expression (n = 0): <none>
[17:28:22.473] Packages needed by future strategies (n = 0): <none>
[17:28:22.474] {
[17:28:22.474]     {
[17:28:22.474]         {
[17:28:22.474]             ...future.startTime <- base::Sys.time()
[17:28:22.474]             {
[17:28:22.474]                 {
[17:28:22.474]                   {
[17:28:22.474]                     {
[17:28:22.474]                       base::local({
[17:28:22.474]                         has_future <- base::requireNamespace("future", 
[17:28:22.474]                           quietly = TRUE)
[17:28:22.474]                         if (has_future) {
[17:28:22.474]                           ns <- base::getNamespace("future")
[17:28:22.474]                           version <- ns[[".package"]][["version"]]
[17:28:22.474]                           if (is.null(version)) 
[17:28:22.474]                             version <- utils::packageVersion("future")
[17:28:22.474]                         }
[17:28:22.474]                         else {
[17:28:22.474]                           version <- NULL
[17:28:22.474]                         }
[17:28:22.474]                         if (!has_future || version < "1.8.0") {
[17:28:22.474]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:22.474]                             "", base::R.version$version.string), 
[17:28:22.474]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:22.474]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:22.474]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:22.474]                               "release", "version")], collapse = " "), 
[17:28:22.474]                             hostname = base::Sys.info()[["nodename"]])
[17:28:22.474]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:22.474]                             info)
[17:28:22.474]                           info <- base::paste(info, collapse = "; ")
[17:28:22.474]                           if (!has_future) {
[17:28:22.474]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:22.474]                               info)
[17:28:22.474]                           }
[17:28:22.474]                           else {
[17:28:22.474]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:22.474]                               info, version)
[17:28:22.474]                           }
[17:28:22.474]                           base::stop(msg)
[17:28:22.474]                         }
[17:28:22.474]                       })
[17:28:22.474]                     }
[17:28:22.474]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:22.474]                     base::options(mc.cores = 1L)
[17:28:22.474]                   }
[17:28:22.474]                   ...future.strategy.old <- future::plan("list")
[17:28:22.474]                   options(future.plan = NULL)
[17:28:22.474]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.474]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:22.474]                 }
[17:28:22.474]                 ...future.workdir <- getwd()
[17:28:22.474]             }
[17:28:22.474]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:22.474]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:22.474]         }
[17:28:22.474]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:22.474]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:22.474]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:22.474]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:22.474]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:22.474]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:22.474]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:22.474]             base::names(...future.oldOptions))
[17:28:22.474]     }
[17:28:22.474]     if (FALSE) {
[17:28:22.474]     }
[17:28:22.474]     else {
[17:28:22.474]         if (TRUE) {
[17:28:22.474]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:22.474]                 open = "w")
[17:28:22.474]         }
[17:28:22.474]         else {
[17:28:22.474]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:22.474]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:22.474]         }
[17:28:22.474]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:22.474]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:22.474]             base::sink(type = "output", split = FALSE)
[17:28:22.474]             base::close(...future.stdout)
[17:28:22.474]         }, add = TRUE)
[17:28:22.474]     }
[17:28:22.474]     ...future.frame <- base::sys.nframe()
[17:28:22.474]     ...future.conditions <- base::list()
[17:28:22.474]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:22.474]     if (FALSE) {
[17:28:22.474]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:22.474]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:22.474]     }
[17:28:22.474]     ...future.result <- base::tryCatch({
[17:28:22.474]         base::withCallingHandlers({
[17:28:22.474]             ...future.value <- base::withVisible(base::local({
[17:28:22.474]                 ...future.makeSendCondition <- base::local({
[17:28:22.474]                   sendCondition <- NULL
[17:28:22.474]                   function(frame = 1L) {
[17:28:22.474]                     if (is.function(sendCondition)) 
[17:28:22.474]                       return(sendCondition)
[17:28:22.474]                     ns <- getNamespace("parallel")
[17:28:22.474]                     if (exists("sendData", mode = "function", 
[17:28:22.474]                       envir = ns)) {
[17:28:22.474]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:22.474]                         envir = ns)
[17:28:22.474]                       envir <- sys.frame(frame)
[17:28:22.474]                       master <- NULL
[17:28:22.474]                       while (!identical(envir, .GlobalEnv) && 
[17:28:22.474]                         !identical(envir, emptyenv())) {
[17:28:22.474]                         if (exists("master", mode = "list", envir = envir, 
[17:28:22.474]                           inherits = FALSE)) {
[17:28:22.474]                           master <- get("master", mode = "list", 
[17:28:22.474]                             envir = envir, inherits = FALSE)
[17:28:22.474]                           if (inherits(master, c("SOCKnode", 
[17:28:22.474]                             "SOCK0node"))) {
[17:28:22.474]                             sendCondition <<- function(cond) {
[17:28:22.474]                               data <- list(type = "VALUE", value = cond, 
[17:28:22.474]                                 success = TRUE)
[17:28:22.474]                               parallel_sendData(master, data)
[17:28:22.474]                             }
[17:28:22.474]                             return(sendCondition)
[17:28:22.474]                           }
[17:28:22.474]                         }
[17:28:22.474]                         frame <- frame + 1L
[17:28:22.474]                         envir <- sys.frame(frame)
[17:28:22.474]                       }
[17:28:22.474]                     }
[17:28:22.474]                     sendCondition <<- function(cond) NULL
[17:28:22.474]                   }
[17:28:22.474]                 })
[17:28:22.474]                 withCallingHandlers({
[17:28:22.474]                   {
[17:28:22.474]                     sample(x, size = 1L)
[17:28:22.474]                   }
[17:28:22.474]                 }, immediateCondition = function(cond) {
[17:28:22.474]                   sendCondition <- ...future.makeSendCondition()
[17:28:22.474]                   sendCondition(cond)
[17:28:22.474]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.474]                   {
[17:28:22.474]                     inherits <- base::inherits
[17:28:22.474]                     invokeRestart <- base::invokeRestart
[17:28:22.474]                     is.null <- base::is.null
[17:28:22.474]                     muffled <- FALSE
[17:28:22.474]                     if (inherits(cond, "message")) {
[17:28:22.474]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:22.474]                       if (muffled) 
[17:28:22.474]                         invokeRestart("muffleMessage")
[17:28:22.474]                     }
[17:28:22.474]                     else if (inherits(cond, "warning")) {
[17:28:22.474]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:22.474]                       if (muffled) 
[17:28:22.474]                         invokeRestart("muffleWarning")
[17:28:22.474]                     }
[17:28:22.474]                     else if (inherits(cond, "condition")) {
[17:28:22.474]                       if (!is.null(pattern)) {
[17:28:22.474]                         computeRestarts <- base::computeRestarts
[17:28:22.474]                         grepl <- base::grepl
[17:28:22.474]                         restarts <- computeRestarts(cond)
[17:28:22.474]                         for (restart in restarts) {
[17:28:22.474]                           name <- restart$name
[17:28:22.474]                           if (is.null(name)) 
[17:28:22.474]                             next
[17:28:22.474]                           if (!grepl(pattern, name)) 
[17:28:22.474]                             next
[17:28:22.474]                           invokeRestart(restart)
[17:28:22.474]                           muffled <- TRUE
[17:28:22.474]                           break
[17:28:22.474]                         }
[17:28:22.474]                       }
[17:28:22.474]                     }
[17:28:22.474]                     invisible(muffled)
[17:28:22.474]                   }
[17:28:22.474]                   muffleCondition(cond)
[17:28:22.474]                 })
[17:28:22.474]             }))
[17:28:22.474]             future::FutureResult(value = ...future.value$value, 
[17:28:22.474]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.474]                   ...future.rng), globalenv = if (FALSE) 
[17:28:22.474]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:22.474]                     ...future.globalenv.names))
[17:28:22.474]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:22.474]         }, condition = base::local({
[17:28:22.474]             c <- base::c
[17:28:22.474]             inherits <- base::inherits
[17:28:22.474]             invokeRestart <- base::invokeRestart
[17:28:22.474]             length <- base::length
[17:28:22.474]             list <- base::list
[17:28:22.474]             seq.int <- base::seq.int
[17:28:22.474]             signalCondition <- base::signalCondition
[17:28:22.474]             sys.calls <- base::sys.calls
[17:28:22.474]             `[[` <- base::`[[`
[17:28:22.474]             `+` <- base::`+`
[17:28:22.474]             `<<-` <- base::`<<-`
[17:28:22.474]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:22.474]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:22.474]                   3L)]
[17:28:22.474]             }
[17:28:22.474]             function(cond) {
[17:28:22.474]                 is_error <- inherits(cond, "error")
[17:28:22.474]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:22.474]                   NULL)
[17:28:22.474]                 if (is_error) {
[17:28:22.474]                   sessionInformation <- function() {
[17:28:22.474]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:22.474]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:22.474]                       search = base::search(), system = base::Sys.info())
[17:28:22.474]                   }
[17:28:22.474]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.474]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:22.474]                     cond$call), session = sessionInformation(), 
[17:28:22.474]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:22.474]                   signalCondition(cond)
[17:28:22.474]                 }
[17:28:22.474]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:22.474]                 "immediateCondition"))) {
[17:28:22.474]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:22.474]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.474]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:22.474]                   if (TRUE && !signal) {
[17:28:22.474]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.474]                     {
[17:28:22.474]                       inherits <- base::inherits
[17:28:22.474]                       invokeRestart <- base::invokeRestart
[17:28:22.474]                       is.null <- base::is.null
[17:28:22.474]                       muffled <- FALSE
[17:28:22.474]                       if (inherits(cond, "message")) {
[17:28:22.474]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.474]                         if (muffled) 
[17:28:22.474]                           invokeRestart("muffleMessage")
[17:28:22.474]                       }
[17:28:22.474]                       else if (inherits(cond, "warning")) {
[17:28:22.474]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.474]                         if (muffled) 
[17:28:22.474]                           invokeRestart("muffleWarning")
[17:28:22.474]                       }
[17:28:22.474]                       else if (inherits(cond, "condition")) {
[17:28:22.474]                         if (!is.null(pattern)) {
[17:28:22.474]                           computeRestarts <- base::computeRestarts
[17:28:22.474]                           grepl <- base::grepl
[17:28:22.474]                           restarts <- computeRestarts(cond)
[17:28:22.474]                           for (restart in restarts) {
[17:28:22.474]                             name <- restart$name
[17:28:22.474]                             if (is.null(name)) 
[17:28:22.474]                               next
[17:28:22.474]                             if (!grepl(pattern, name)) 
[17:28:22.474]                               next
[17:28:22.474]                             invokeRestart(restart)
[17:28:22.474]                             muffled <- TRUE
[17:28:22.474]                             break
[17:28:22.474]                           }
[17:28:22.474]                         }
[17:28:22.474]                       }
[17:28:22.474]                       invisible(muffled)
[17:28:22.474]                     }
[17:28:22.474]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.474]                   }
[17:28:22.474]                 }
[17:28:22.474]                 else {
[17:28:22.474]                   if (TRUE) {
[17:28:22.474]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.474]                     {
[17:28:22.474]                       inherits <- base::inherits
[17:28:22.474]                       invokeRestart <- base::invokeRestart
[17:28:22.474]                       is.null <- base::is.null
[17:28:22.474]                       muffled <- FALSE
[17:28:22.474]                       if (inherits(cond, "message")) {
[17:28:22.474]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.474]                         if (muffled) 
[17:28:22.474]                           invokeRestart("muffleMessage")
[17:28:22.474]                       }
[17:28:22.474]                       else if (inherits(cond, "warning")) {
[17:28:22.474]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.474]                         if (muffled) 
[17:28:22.474]                           invokeRestart("muffleWarning")
[17:28:22.474]                       }
[17:28:22.474]                       else if (inherits(cond, "condition")) {
[17:28:22.474]                         if (!is.null(pattern)) {
[17:28:22.474]                           computeRestarts <- base::computeRestarts
[17:28:22.474]                           grepl <- base::grepl
[17:28:22.474]                           restarts <- computeRestarts(cond)
[17:28:22.474]                           for (restart in restarts) {
[17:28:22.474]                             name <- restart$name
[17:28:22.474]                             if (is.null(name)) 
[17:28:22.474]                               next
[17:28:22.474]                             if (!grepl(pattern, name)) 
[17:28:22.474]                               next
[17:28:22.474]                             invokeRestart(restart)
[17:28:22.474]                             muffled <- TRUE
[17:28:22.474]                             break
[17:28:22.474]                           }
[17:28:22.474]                         }
[17:28:22.474]                       }
[17:28:22.474]                       invisible(muffled)
[17:28:22.474]                     }
[17:28:22.474]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.474]                   }
[17:28:22.474]                 }
[17:28:22.474]             }
[17:28:22.474]         }))
[17:28:22.474]     }, error = function(ex) {
[17:28:22.474]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:22.474]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.474]                 ...future.rng), started = ...future.startTime, 
[17:28:22.474]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:22.474]             version = "1.8"), class = "FutureResult")
[17:28:22.474]     }, finally = {
[17:28:22.474]         if (!identical(...future.workdir, getwd())) 
[17:28:22.474]             setwd(...future.workdir)
[17:28:22.474]         {
[17:28:22.474]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:22.474]                 ...future.oldOptions$nwarnings <- NULL
[17:28:22.474]             }
[17:28:22.474]             base::options(...future.oldOptions)
[17:28:22.474]             if (.Platform$OS.type == "windows") {
[17:28:22.474]                 old_names <- names(...future.oldEnvVars)
[17:28:22.474]                 envs <- base::Sys.getenv()
[17:28:22.474]                 names <- names(envs)
[17:28:22.474]                 common <- intersect(names, old_names)
[17:28:22.474]                 added <- setdiff(names, old_names)
[17:28:22.474]                 removed <- setdiff(old_names, names)
[17:28:22.474]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:22.474]                   envs[common]]
[17:28:22.474]                 NAMES <- toupper(changed)
[17:28:22.474]                 args <- list()
[17:28:22.474]                 for (kk in seq_along(NAMES)) {
[17:28:22.474]                   name <- changed[[kk]]
[17:28:22.474]                   NAME <- NAMES[[kk]]
[17:28:22.474]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.474]                     next
[17:28:22.474]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.474]                 }
[17:28:22.474]                 NAMES <- toupper(added)
[17:28:22.474]                 for (kk in seq_along(NAMES)) {
[17:28:22.474]                   name <- added[[kk]]
[17:28:22.474]                   NAME <- NAMES[[kk]]
[17:28:22.474]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.474]                     next
[17:28:22.474]                   args[[name]] <- ""
[17:28:22.474]                 }
[17:28:22.474]                 NAMES <- toupper(removed)
[17:28:22.474]                 for (kk in seq_along(NAMES)) {
[17:28:22.474]                   name <- removed[[kk]]
[17:28:22.474]                   NAME <- NAMES[[kk]]
[17:28:22.474]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.474]                     next
[17:28:22.474]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.474]                 }
[17:28:22.474]                 if (length(args) > 0) 
[17:28:22.474]                   base::do.call(base::Sys.setenv, args = args)
[17:28:22.474]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:22.474]             }
[17:28:22.474]             else {
[17:28:22.474]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:22.474]             }
[17:28:22.474]             {
[17:28:22.474]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:22.474]                   0L) {
[17:28:22.474]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:22.474]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:22.474]                   base::options(opts)
[17:28:22.474]                 }
[17:28:22.474]                 {
[17:28:22.474]                   {
[17:28:22.474]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:22.474]                     NULL
[17:28:22.474]                   }
[17:28:22.474]                   options(future.plan = NULL)
[17:28:22.474]                   if (is.na(NA_character_)) 
[17:28:22.474]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.474]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:22.474]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:22.474]                     .init = FALSE)
[17:28:22.474]                 }
[17:28:22.474]             }
[17:28:22.474]         }
[17:28:22.474]     })
[17:28:22.474]     if (TRUE) {
[17:28:22.474]         base::sink(type = "output", split = FALSE)
[17:28:22.474]         if (TRUE) {
[17:28:22.474]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:22.474]         }
[17:28:22.474]         else {
[17:28:22.474]             ...future.result["stdout"] <- base::list(NULL)
[17:28:22.474]         }
[17:28:22.474]         base::close(...future.stdout)
[17:28:22.474]         ...future.stdout <- NULL
[17:28:22.474]     }
[17:28:22.474]     ...future.result$conditions <- ...future.conditions
[17:28:22.474]     ...future.result$finished <- base::Sys.time()
[17:28:22.474]     ...future.result
[17:28:22.474] }
[17:28:22.478] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:22.492] receiveMessageFromWorker() for ClusterFuture ...
[17:28:22.492] - Validating connection of MultisessionFuture
[17:28:22.493] - received message: FutureResult
[17:28:22.493] - Received FutureResult
[17:28:22.493] - Erased future from FutureRegistry
[17:28:22.493] result() for ClusterFuture ...
[17:28:22.493] - result already collected: FutureResult
[17:28:22.493] result() for ClusterFuture ... done
[17:28:22.494] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:22.494] result() for ClusterFuture ...
[17:28:22.494] - result already collected: FutureResult
[17:28:22.494] result() for ClusterFuture ... done
[17:28:22.494] result() for ClusterFuture ...
[17:28:22.494] - result already collected: FutureResult
[17:28:22.495] result() for ClusterFuture ... done
[17:28:22.495] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:22.496] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:22.496] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:22.496] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:22.497] MultisessionFuture started
[17:28:22.497] - Launch lazy future ... done
[17:28:22.497] run() for 'MultisessionFuture' ... done
[17:28:22.498] getGlobalsAndPackages() ...
[17:28:22.498] Searching for globals...
[17:28:22.499] - globals found: [3] '{', 'sample', 'x'
[17:28:22.499] Searching for globals ... DONE
[17:28:22.500] Resolving globals: FALSE
[17:28:22.500] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:22.500] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:22.501] - globals: [1] 'x'
[17:28:22.501] 
[17:28:22.501] getGlobalsAndPackages() ... DONE
[17:28:22.501] run() for 'Future' ...
[17:28:22.504] - state: 'created'
[17:28:22.504] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:22.518] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:22.518] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:22.518]   - Field: 'node'
[17:28:22.519]   - Field: 'label'
[17:28:22.519]   - Field: 'local'
[17:28:22.519]   - Field: 'owner'
[17:28:22.519]   - Field: 'envir'
[17:28:22.519]   - Field: 'workers'
[17:28:22.519]   - Field: 'packages'
[17:28:22.520]   - Field: 'gc'
[17:28:22.520]   - Field: 'conditions'
[17:28:22.520]   - Field: 'persistent'
[17:28:22.520]   - Field: 'expr'
[17:28:22.520]   - Field: 'uuid'
[17:28:22.521]   - Field: 'seed'
[17:28:22.521]   - Field: 'version'
[17:28:22.521]   - Field: 'result'
[17:28:22.521]   - Field: 'asynchronous'
[17:28:22.521]   - Field: 'calls'
[17:28:22.521]   - Field: 'globals'
[17:28:22.522]   - Field: 'stdout'
[17:28:22.522]   - Field: 'earlySignal'
[17:28:22.522]   - Field: 'lazy'
[17:28:22.522]   - Field: 'state'
[17:28:22.522] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:22.522] - Launch lazy future ...
[17:28:22.523] Packages needed by the future expression (n = 0): <none>
[17:28:22.523] Packages needed by future strategies (n = 0): <none>
[17:28:22.524] {
[17:28:22.524]     {
[17:28:22.524]         {
[17:28:22.524]             ...future.startTime <- base::Sys.time()
[17:28:22.524]             {
[17:28:22.524]                 {
[17:28:22.524]                   {
[17:28:22.524]                     {
[17:28:22.524]                       base::local({
[17:28:22.524]                         has_future <- base::requireNamespace("future", 
[17:28:22.524]                           quietly = TRUE)
[17:28:22.524]                         if (has_future) {
[17:28:22.524]                           ns <- base::getNamespace("future")
[17:28:22.524]                           version <- ns[[".package"]][["version"]]
[17:28:22.524]                           if (is.null(version)) 
[17:28:22.524]                             version <- utils::packageVersion("future")
[17:28:22.524]                         }
[17:28:22.524]                         else {
[17:28:22.524]                           version <- NULL
[17:28:22.524]                         }
[17:28:22.524]                         if (!has_future || version < "1.8.0") {
[17:28:22.524]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:22.524]                             "", base::R.version$version.string), 
[17:28:22.524]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:22.524]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:22.524]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:22.524]                               "release", "version")], collapse = " "), 
[17:28:22.524]                             hostname = base::Sys.info()[["nodename"]])
[17:28:22.524]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:22.524]                             info)
[17:28:22.524]                           info <- base::paste(info, collapse = "; ")
[17:28:22.524]                           if (!has_future) {
[17:28:22.524]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:22.524]                               info)
[17:28:22.524]                           }
[17:28:22.524]                           else {
[17:28:22.524]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:22.524]                               info, version)
[17:28:22.524]                           }
[17:28:22.524]                           base::stop(msg)
[17:28:22.524]                         }
[17:28:22.524]                       })
[17:28:22.524]                     }
[17:28:22.524]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:22.524]                     base::options(mc.cores = 1L)
[17:28:22.524]                   }
[17:28:22.524]                   ...future.strategy.old <- future::plan("list")
[17:28:22.524]                   options(future.plan = NULL)
[17:28:22.524]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.524]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:22.524]                 }
[17:28:22.524]                 ...future.workdir <- getwd()
[17:28:22.524]             }
[17:28:22.524]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:22.524]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:22.524]         }
[17:28:22.524]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:22.524]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:22.524]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:22.524]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:22.524]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:22.524]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:22.524]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:22.524]             base::names(...future.oldOptions))
[17:28:22.524]     }
[17:28:22.524]     if (FALSE) {
[17:28:22.524]     }
[17:28:22.524]     else {
[17:28:22.524]         if (TRUE) {
[17:28:22.524]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:22.524]                 open = "w")
[17:28:22.524]         }
[17:28:22.524]         else {
[17:28:22.524]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:22.524]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:22.524]         }
[17:28:22.524]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:22.524]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:22.524]             base::sink(type = "output", split = FALSE)
[17:28:22.524]             base::close(...future.stdout)
[17:28:22.524]         }, add = TRUE)
[17:28:22.524]     }
[17:28:22.524]     ...future.frame <- base::sys.nframe()
[17:28:22.524]     ...future.conditions <- base::list()
[17:28:22.524]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:22.524]     if (FALSE) {
[17:28:22.524]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:22.524]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:22.524]     }
[17:28:22.524]     ...future.result <- base::tryCatch({
[17:28:22.524]         base::withCallingHandlers({
[17:28:22.524]             ...future.value <- base::withVisible(base::local({
[17:28:22.524]                 ...future.makeSendCondition <- base::local({
[17:28:22.524]                   sendCondition <- NULL
[17:28:22.524]                   function(frame = 1L) {
[17:28:22.524]                     if (is.function(sendCondition)) 
[17:28:22.524]                       return(sendCondition)
[17:28:22.524]                     ns <- getNamespace("parallel")
[17:28:22.524]                     if (exists("sendData", mode = "function", 
[17:28:22.524]                       envir = ns)) {
[17:28:22.524]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:22.524]                         envir = ns)
[17:28:22.524]                       envir <- sys.frame(frame)
[17:28:22.524]                       master <- NULL
[17:28:22.524]                       while (!identical(envir, .GlobalEnv) && 
[17:28:22.524]                         !identical(envir, emptyenv())) {
[17:28:22.524]                         if (exists("master", mode = "list", envir = envir, 
[17:28:22.524]                           inherits = FALSE)) {
[17:28:22.524]                           master <- get("master", mode = "list", 
[17:28:22.524]                             envir = envir, inherits = FALSE)
[17:28:22.524]                           if (inherits(master, c("SOCKnode", 
[17:28:22.524]                             "SOCK0node"))) {
[17:28:22.524]                             sendCondition <<- function(cond) {
[17:28:22.524]                               data <- list(type = "VALUE", value = cond, 
[17:28:22.524]                                 success = TRUE)
[17:28:22.524]                               parallel_sendData(master, data)
[17:28:22.524]                             }
[17:28:22.524]                             return(sendCondition)
[17:28:22.524]                           }
[17:28:22.524]                         }
[17:28:22.524]                         frame <- frame + 1L
[17:28:22.524]                         envir <- sys.frame(frame)
[17:28:22.524]                       }
[17:28:22.524]                     }
[17:28:22.524]                     sendCondition <<- function(cond) NULL
[17:28:22.524]                   }
[17:28:22.524]                 })
[17:28:22.524]                 withCallingHandlers({
[17:28:22.524]                   {
[17:28:22.524]                     sample(x, size = 1L)
[17:28:22.524]                   }
[17:28:22.524]                 }, immediateCondition = function(cond) {
[17:28:22.524]                   sendCondition <- ...future.makeSendCondition()
[17:28:22.524]                   sendCondition(cond)
[17:28:22.524]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.524]                   {
[17:28:22.524]                     inherits <- base::inherits
[17:28:22.524]                     invokeRestart <- base::invokeRestart
[17:28:22.524]                     is.null <- base::is.null
[17:28:22.524]                     muffled <- FALSE
[17:28:22.524]                     if (inherits(cond, "message")) {
[17:28:22.524]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:22.524]                       if (muffled) 
[17:28:22.524]                         invokeRestart("muffleMessage")
[17:28:22.524]                     }
[17:28:22.524]                     else if (inherits(cond, "warning")) {
[17:28:22.524]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:22.524]                       if (muffled) 
[17:28:22.524]                         invokeRestart("muffleWarning")
[17:28:22.524]                     }
[17:28:22.524]                     else if (inherits(cond, "condition")) {
[17:28:22.524]                       if (!is.null(pattern)) {
[17:28:22.524]                         computeRestarts <- base::computeRestarts
[17:28:22.524]                         grepl <- base::grepl
[17:28:22.524]                         restarts <- computeRestarts(cond)
[17:28:22.524]                         for (restart in restarts) {
[17:28:22.524]                           name <- restart$name
[17:28:22.524]                           if (is.null(name)) 
[17:28:22.524]                             next
[17:28:22.524]                           if (!grepl(pattern, name)) 
[17:28:22.524]                             next
[17:28:22.524]                           invokeRestart(restart)
[17:28:22.524]                           muffled <- TRUE
[17:28:22.524]                           break
[17:28:22.524]                         }
[17:28:22.524]                       }
[17:28:22.524]                     }
[17:28:22.524]                     invisible(muffled)
[17:28:22.524]                   }
[17:28:22.524]                   muffleCondition(cond)
[17:28:22.524]                 })
[17:28:22.524]             }))
[17:28:22.524]             future::FutureResult(value = ...future.value$value, 
[17:28:22.524]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.524]                   ...future.rng), globalenv = if (FALSE) 
[17:28:22.524]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:22.524]                     ...future.globalenv.names))
[17:28:22.524]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:22.524]         }, condition = base::local({
[17:28:22.524]             c <- base::c
[17:28:22.524]             inherits <- base::inherits
[17:28:22.524]             invokeRestart <- base::invokeRestart
[17:28:22.524]             length <- base::length
[17:28:22.524]             list <- base::list
[17:28:22.524]             seq.int <- base::seq.int
[17:28:22.524]             signalCondition <- base::signalCondition
[17:28:22.524]             sys.calls <- base::sys.calls
[17:28:22.524]             `[[` <- base::`[[`
[17:28:22.524]             `+` <- base::`+`
[17:28:22.524]             `<<-` <- base::`<<-`
[17:28:22.524]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:22.524]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:22.524]                   3L)]
[17:28:22.524]             }
[17:28:22.524]             function(cond) {
[17:28:22.524]                 is_error <- inherits(cond, "error")
[17:28:22.524]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:22.524]                   NULL)
[17:28:22.524]                 if (is_error) {
[17:28:22.524]                   sessionInformation <- function() {
[17:28:22.524]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:22.524]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:22.524]                       search = base::search(), system = base::Sys.info())
[17:28:22.524]                   }
[17:28:22.524]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.524]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:22.524]                     cond$call), session = sessionInformation(), 
[17:28:22.524]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:22.524]                   signalCondition(cond)
[17:28:22.524]                 }
[17:28:22.524]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:22.524]                 "immediateCondition"))) {
[17:28:22.524]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:22.524]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.524]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:22.524]                   if (TRUE && !signal) {
[17:28:22.524]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.524]                     {
[17:28:22.524]                       inherits <- base::inherits
[17:28:22.524]                       invokeRestart <- base::invokeRestart
[17:28:22.524]                       is.null <- base::is.null
[17:28:22.524]                       muffled <- FALSE
[17:28:22.524]                       if (inherits(cond, "message")) {
[17:28:22.524]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.524]                         if (muffled) 
[17:28:22.524]                           invokeRestart("muffleMessage")
[17:28:22.524]                       }
[17:28:22.524]                       else if (inherits(cond, "warning")) {
[17:28:22.524]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.524]                         if (muffled) 
[17:28:22.524]                           invokeRestart("muffleWarning")
[17:28:22.524]                       }
[17:28:22.524]                       else if (inherits(cond, "condition")) {
[17:28:22.524]                         if (!is.null(pattern)) {
[17:28:22.524]                           computeRestarts <- base::computeRestarts
[17:28:22.524]                           grepl <- base::grepl
[17:28:22.524]                           restarts <- computeRestarts(cond)
[17:28:22.524]                           for (restart in restarts) {
[17:28:22.524]                             name <- restart$name
[17:28:22.524]                             if (is.null(name)) 
[17:28:22.524]                               next
[17:28:22.524]                             if (!grepl(pattern, name)) 
[17:28:22.524]                               next
[17:28:22.524]                             invokeRestart(restart)
[17:28:22.524]                             muffled <- TRUE
[17:28:22.524]                             break
[17:28:22.524]                           }
[17:28:22.524]                         }
[17:28:22.524]                       }
[17:28:22.524]                       invisible(muffled)
[17:28:22.524]                     }
[17:28:22.524]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.524]                   }
[17:28:22.524]                 }
[17:28:22.524]                 else {
[17:28:22.524]                   if (TRUE) {
[17:28:22.524]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.524]                     {
[17:28:22.524]                       inherits <- base::inherits
[17:28:22.524]                       invokeRestart <- base::invokeRestart
[17:28:22.524]                       is.null <- base::is.null
[17:28:22.524]                       muffled <- FALSE
[17:28:22.524]                       if (inherits(cond, "message")) {
[17:28:22.524]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.524]                         if (muffled) 
[17:28:22.524]                           invokeRestart("muffleMessage")
[17:28:22.524]                       }
[17:28:22.524]                       else if (inherits(cond, "warning")) {
[17:28:22.524]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.524]                         if (muffled) 
[17:28:22.524]                           invokeRestart("muffleWarning")
[17:28:22.524]                       }
[17:28:22.524]                       else if (inherits(cond, "condition")) {
[17:28:22.524]                         if (!is.null(pattern)) {
[17:28:22.524]                           computeRestarts <- base::computeRestarts
[17:28:22.524]                           grepl <- base::grepl
[17:28:22.524]                           restarts <- computeRestarts(cond)
[17:28:22.524]                           for (restart in restarts) {
[17:28:22.524]                             name <- restart$name
[17:28:22.524]                             if (is.null(name)) 
[17:28:22.524]                               next
[17:28:22.524]                             if (!grepl(pattern, name)) 
[17:28:22.524]                               next
[17:28:22.524]                             invokeRestart(restart)
[17:28:22.524]                             muffled <- TRUE
[17:28:22.524]                             break
[17:28:22.524]                           }
[17:28:22.524]                         }
[17:28:22.524]                       }
[17:28:22.524]                       invisible(muffled)
[17:28:22.524]                     }
[17:28:22.524]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.524]                   }
[17:28:22.524]                 }
[17:28:22.524]             }
[17:28:22.524]         }))
[17:28:22.524]     }, error = function(ex) {
[17:28:22.524]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:22.524]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.524]                 ...future.rng), started = ...future.startTime, 
[17:28:22.524]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:22.524]             version = "1.8"), class = "FutureResult")
[17:28:22.524]     }, finally = {
[17:28:22.524]         if (!identical(...future.workdir, getwd())) 
[17:28:22.524]             setwd(...future.workdir)
[17:28:22.524]         {
[17:28:22.524]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:22.524]                 ...future.oldOptions$nwarnings <- NULL
[17:28:22.524]             }
[17:28:22.524]             base::options(...future.oldOptions)
[17:28:22.524]             if (.Platform$OS.type == "windows") {
[17:28:22.524]                 old_names <- names(...future.oldEnvVars)
[17:28:22.524]                 envs <- base::Sys.getenv()
[17:28:22.524]                 names <- names(envs)
[17:28:22.524]                 common <- intersect(names, old_names)
[17:28:22.524]                 added <- setdiff(names, old_names)
[17:28:22.524]                 removed <- setdiff(old_names, names)
[17:28:22.524]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:22.524]                   envs[common]]
[17:28:22.524]                 NAMES <- toupper(changed)
[17:28:22.524]                 args <- list()
[17:28:22.524]                 for (kk in seq_along(NAMES)) {
[17:28:22.524]                   name <- changed[[kk]]
[17:28:22.524]                   NAME <- NAMES[[kk]]
[17:28:22.524]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.524]                     next
[17:28:22.524]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.524]                 }
[17:28:22.524]                 NAMES <- toupper(added)
[17:28:22.524]                 for (kk in seq_along(NAMES)) {
[17:28:22.524]                   name <- added[[kk]]
[17:28:22.524]                   NAME <- NAMES[[kk]]
[17:28:22.524]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.524]                     next
[17:28:22.524]                   args[[name]] <- ""
[17:28:22.524]                 }
[17:28:22.524]                 NAMES <- toupper(removed)
[17:28:22.524]                 for (kk in seq_along(NAMES)) {
[17:28:22.524]                   name <- removed[[kk]]
[17:28:22.524]                   NAME <- NAMES[[kk]]
[17:28:22.524]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.524]                     next
[17:28:22.524]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.524]                 }
[17:28:22.524]                 if (length(args) > 0) 
[17:28:22.524]                   base::do.call(base::Sys.setenv, args = args)
[17:28:22.524]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:22.524]             }
[17:28:22.524]             else {
[17:28:22.524]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:22.524]             }
[17:28:22.524]             {
[17:28:22.524]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:22.524]                   0L) {
[17:28:22.524]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:22.524]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:22.524]                   base::options(opts)
[17:28:22.524]                 }
[17:28:22.524]                 {
[17:28:22.524]                   {
[17:28:22.524]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:22.524]                     NULL
[17:28:22.524]                   }
[17:28:22.524]                   options(future.plan = NULL)
[17:28:22.524]                   if (is.na(NA_character_)) 
[17:28:22.524]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.524]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:22.524]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:22.524]                     .init = FALSE)
[17:28:22.524]                 }
[17:28:22.524]             }
[17:28:22.524]         }
[17:28:22.524]     })
[17:28:22.524]     if (TRUE) {
[17:28:22.524]         base::sink(type = "output", split = FALSE)
[17:28:22.524]         if (TRUE) {
[17:28:22.524]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:22.524]         }
[17:28:22.524]         else {
[17:28:22.524]             ...future.result["stdout"] <- base::list(NULL)
[17:28:22.524]         }
[17:28:22.524]         base::close(...future.stdout)
[17:28:22.524]         ...future.stdout <- NULL
[17:28:22.524]     }
[17:28:22.524]     ...future.result$conditions <- ...future.conditions
[17:28:22.524]     ...future.result$finished <- base::Sys.time()
[17:28:22.524]     ...future.result
[17:28:22.524] }
[17:28:22.528] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:22.539] receiveMessageFromWorker() for ClusterFuture ...
[17:28:22.539] - Validating connection of MultisessionFuture
[17:28:22.539] - received message: FutureResult
[17:28:22.540] - Received FutureResult
[17:28:22.540] - Erased future from FutureRegistry
[17:28:22.540] result() for ClusterFuture ...
[17:28:22.540] - result already collected: FutureResult
[17:28:22.540] result() for ClusterFuture ... done
[17:28:22.540] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:22.541] result() for ClusterFuture ...
[17:28:22.541] - result already collected: FutureResult
[17:28:22.541] result() for ClusterFuture ... done
[17:28:22.541] result() for ClusterFuture ...
[17:28:22.541] - result already collected: FutureResult
[17:28:22.541] result() for ClusterFuture ... done
[17:28:22.542] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[17:28:22.542] Exporting 'x' (64 bytes) to cluster node #1 ...
[17:28:22.543] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[17:28:22.543] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[17:28:22.543] MultisessionFuture started
[17:28:22.544] - Launch lazy future ... done
[17:28:22.544] run() for 'MultisessionFuture' ... done
[17:28:22.544] getGlobalsAndPackages() ...
[17:28:22.545] Searching for globals...
[17:28:22.546] - globals found: [3] '{', 'sample', 'x'
[17:28:22.546] Searching for globals ... DONE
[17:28:22.546] Resolving globals: FALSE
[17:28:22.547] The total size of the 1 globals is 64 bytes (64 bytes)
[17:28:22.547] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[17:28:22.547] - globals: [1] 'x'
[17:28:22.547] 
[17:28:22.548] getGlobalsAndPackages() ... DONE
[17:28:22.548] run() for 'Future' ...
[17:28:22.548] - state: 'created'
[17:28:22.548] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:22.563] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:22.564] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:22.564]   - Field: 'node'
[17:28:22.564]   - Field: 'label'
[17:28:22.564]   - Field: 'local'
[17:28:22.564]   - Field: 'owner'
[17:28:22.565]   - Field: 'envir'
[17:28:22.565]   - Field: 'workers'
[17:28:22.565]   - Field: 'packages'
[17:28:22.565]   - Field: 'gc'
[17:28:22.565]   - Field: 'conditions'
[17:28:22.565]   - Field: 'persistent'
[17:28:22.566]   - Field: 'expr'
[17:28:22.566]   - Field: 'uuid'
[17:28:22.566]   - Field: 'seed'
[17:28:22.566]   - Field: 'version'
[17:28:22.566]   - Field: 'result'
[17:28:22.567]   - Field: 'asynchronous'
[17:28:22.567]   - Field: 'calls'
[17:28:22.567]   - Field: 'globals'
[17:28:22.567]   - Field: 'stdout'
[17:28:22.567]   - Field: 'earlySignal'
[17:28:22.567]   - Field: 'lazy'
[17:28:22.568]   - Field: 'state'
[17:28:22.568] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:22.568] - Launch lazy future ...
[17:28:22.568] Packages needed by the future expression (n = 0): <none>
[17:28:22.568] Packages needed by future strategies (n = 0): <none>
[17:28:22.569] {
[17:28:22.569]     {
[17:28:22.569]         {
[17:28:22.569]             ...future.startTime <- base::Sys.time()
[17:28:22.569]             {
[17:28:22.569]                 {
[17:28:22.569]                   {
[17:28:22.569]                     {
[17:28:22.569]                       base::local({
[17:28:22.569]                         has_future <- base::requireNamespace("future", 
[17:28:22.569]                           quietly = TRUE)
[17:28:22.569]                         if (has_future) {
[17:28:22.569]                           ns <- base::getNamespace("future")
[17:28:22.569]                           version <- ns[[".package"]][["version"]]
[17:28:22.569]                           if (is.null(version)) 
[17:28:22.569]                             version <- utils::packageVersion("future")
[17:28:22.569]                         }
[17:28:22.569]                         else {
[17:28:22.569]                           version <- NULL
[17:28:22.569]                         }
[17:28:22.569]                         if (!has_future || version < "1.8.0") {
[17:28:22.569]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:22.569]                             "", base::R.version$version.string), 
[17:28:22.569]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:22.569]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:22.569]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:22.569]                               "release", "version")], collapse = " "), 
[17:28:22.569]                             hostname = base::Sys.info()[["nodename"]])
[17:28:22.569]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:22.569]                             info)
[17:28:22.569]                           info <- base::paste(info, collapse = "; ")
[17:28:22.569]                           if (!has_future) {
[17:28:22.569]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:22.569]                               info)
[17:28:22.569]                           }
[17:28:22.569]                           else {
[17:28:22.569]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:22.569]                               info, version)
[17:28:22.569]                           }
[17:28:22.569]                           base::stop(msg)
[17:28:22.569]                         }
[17:28:22.569]                       })
[17:28:22.569]                     }
[17:28:22.569]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:22.569]                     base::options(mc.cores = 1L)
[17:28:22.569]                   }
[17:28:22.569]                   ...future.strategy.old <- future::plan("list")
[17:28:22.569]                   options(future.plan = NULL)
[17:28:22.569]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.569]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:22.569]                 }
[17:28:22.569]                 ...future.workdir <- getwd()
[17:28:22.569]             }
[17:28:22.569]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:22.569]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:22.569]         }
[17:28:22.569]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:28:22.569]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:22.569]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:28:22.569]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:28:22.569]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:28:22.569]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:22.569]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:22.569]             base::names(...future.oldOptions))
[17:28:22.569]     }
[17:28:22.569]     if (FALSE) {
[17:28:22.569]     }
[17:28:22.569]     else {
[17:28:22.569]         if (TRUE) {
[17:28:22.569]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:22.569]                 open = "w")
[17:28:22.569]         }
[17:28:22.569]         else {
[17:28:22.569]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:22.569]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:22.569]         }
[17:28:22.569]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:22.569]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:22.569]             base::sink(type = "output", split = FALSE)
[17:28:22.569]             base::close(...future.stdout)
[17:28:22.569]         }, add = TRUE)
[17:28:22.569]     }
[17:28:22.569]     ...future.frame <- base::sys.nframe()
[17:28:22.569]     ...future.conditions <- base::list()
[17:28:22.569]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:22.569]     if (FALSE) {
[17:28:22.569]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:22.569]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:22.569]     }
[17:28:22.569]     ...future.result <- base::tryCatch({
[17:28:22.569]         base::withCallingHandlers({
[17:28:22.569]             ...future.value <- base::withVisible(base::local({
[17:28:22.569]                 ...future.makeSendCondition <- base::local({
[17:28:22.569]                   sendCondition <- NULL
[17:28:22.569]                   function(frame = 1L) {
[17:28:22.569]                     if (is.function(sendCondition)) 
[17:28:22.569]                       return(sendCondition)
[17:28:22.569]                     ns <- getNamespace("parallel")
[17:28:22.569]                     if (exists("sendData", mode = "function", 
[17:28:22.569]                       envir = ns)) {
[17:28:22.569]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:22.569]                         envir = ns)
[17:28:22.569]                       envir <- sys.frame(frame)
[17:28:22.569]                       master <- NULL
[17:28:22.569]                       while (!identical(envir, .GlobalEnv) && 
[17:28:22.569]                         !identical(envir, emptyenv())) {
[17:28:22.569]                         if (exists("master", mode = "list", envir = envir, 
[17:28:22.569]                           inherits = FALSE)) {
[17:28:22.569]                           master <- get("master", mode = "list", 
[17:28:22.569]                             envir = envir, inherits = FALSE)
[17:28:22.569]                           if (inherits(master, c("SOCKnode", 
[17:28:22.569]                             "SOCK0node"))) {
[17:28:22.569]                             sendCondition <<- function(cond) {
[17:28:22.569]                               data <- list(type = "VALUE", value = cond, 
[17:28:22.569]                                 success = TRUE)
[17:28:22.569]                               parallel_sendData(master, data)
[17:28:22.569]                             }
[17:28:22.569]                             return(sendCondition)
[17:28:22.569]                           }
[17:28:22.569]                         }
[17:28:22.569]                         frame <- frame + 1L
[17:28:22.569]                         envir <- sys.frame(frame)
[17:28:22.569]                       }
[17:28:22.569]                     }
[17:28:22.569]                     sendCondition <<- function(cond) NULL
[17:28:22.569]                   }
[17:28:22.569]                 })
[17:28:22.569]                 withCallingHandlers({
[17:28:22.569]                   {
[17:28:22.569]                     sample(x, size = 1L)
[17:28:22.569]                   }
[17:28:22.569]                 }, immediateCondition = function(cond) {
[17:28:22.569]                   sendCondition <- ...future.makeSendCondition()
[17:28:22.569]                   sendCondition(cond)
[17:28:22.569]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.569]                   {
[17:28:22.569]                     inherits <- base::inherits
[17:28:22.569]                     invokeRestart <- base::invokeRestart
[17:28:22.569]                     is.null <- base::is.null
[17:28:22.569]                     muffled <- FALSE
[17:28:22.569]                     if (inherits(cond, "message")) {
[17:28:22.569]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:22.569]                       if (muffled) 
[17:28:22.569]                         invokeRestart("muffleMessage")
[17:28:22.569]                     }
[17:28:22.569]                     else if (inherits(cond, "warning")) {
[17:28:22.569]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:22.569]                       if (muffled) 
[17:28:22.569]                         invokeRestart("muffleWarning")
[17:28:22.569]                     }
[17:28:22.569]                     else if (inherits(cond, "condition")) {
[17:28:22.569]                       if (!is.null(pattern)) {
[17:28:22.569]                         computeRestarts <- base::computeRestarts
[17:28:22.569]                         grepl <- base::grepl
[17:28:22.569]                         restarts <- computeRestarts(cond)
[17:28:22.569]                         for (restart in restarts) {
[17:28:22.569]                           name <- restart$name
[17:28:22.569]                           if (is.null(name)) 
[17:28:22.569]                             next
[17:28:22.569]                           if (!grepl(pattern, name)) 
[17:28:22.569]                             next
[17:28:22.569]                           invokeRestart(restart)
[17:28:22.569]                           muffled <- TRUE
[17:28:22.569]                           break
[17:28:22.569]                         }
[17:28:22.569]                       }
[17:28:22.569]                     }
[17:28:22.569]                     invisible(muffled)
[17:28:22.569]                   }
[17:28:22.569]                   muffleCondition(cond)
[17:28:22.569]                 })
[17:28:22.569]             }))
[17:28:22.569]             future::FutureResult(value = ...future.value$value, 
[17:28:22.569]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.569]                   ...future.rng), globalenv = if (FALSE) 
[17:28:22.569]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:22.569]                     ...future.globalenv.names))
[17:28:22.569]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:22.569]         }, condition = base::local({
[17:28:22.569]             c <- base::c
[17:28:22.569]             inherits <- base::inherits
[17:28:22.569]             invokeRestart <- base::invokeRestart
[17:28:22.569]             length <- base::length
[17:28:22.569]             list <- base::list
[17:28:22.569]             seq.int <- base::seq.int
[17:28:22.569]             signalCondition <- base::signalCondition
[17:28:22.569]             sys.calls <- base::sys.calls
[17:28:22.569]             `[[` <- base::`[[`
[17:28:22.569]             `+` <- base::`+`
[17:28:22.569]             `<<-` <- base::`<<-`
[17:28:22.569]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:22.569]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:22.569]                   3L)]
[17:28:22.569]             }
[17:28:22.569]             function(cond) {
[17:28:22.569]                 is_error <- inherits(cond, "error")
[17:28:22.569]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:22.569]                   NULL)
[17:28:22.569]                 if (is_error) {
[17:28:22.569]                   sessionInformation <- function() {
[17:28:22.569]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:22.569]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:22.569]                       search = base::search(), system = base::Sys.info())
[17:28:22.569]                   }
[17:28:22.569]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.569]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:22.569]                     cond$call), session = sessionInformation(), 
[17:28:22.569]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:22.569]                   signalCondition(cond)
[17:28:22.569]                 }
[17:28:22.569]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:22.569]                 "immediateCondition"))) {
[17:28:22.569]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:22.569]                   ...future.conditions[[length(...future.conditions) + 
[17:28:22.569]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:22.569]                   if (TRUE && !signal) {
[17:28:22.569]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.569]                     {
[17:28:22.569]                       inherits <- base::inherits
[17:28:22.569]                       invokeRestart <- base::invokeRestart
[17:28:22.569]                       is.null <- base::is.null
[17:28:22.569]                       muffled <- FALSE
[17:28:22.569]                       if (inherits(cond, "message")) {
[17:28:22.569]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.569]                         if (muffled) 
[17:28:22.569]                           invokeRestart("muffleMessage")
[17:28:22.569]                       }
[17:28:22.569]                       else if (inherits(cond, "warning")) {
[17:28:22.569]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.569]                         if (muffled) 
[17:28:22.569]                           invokeRestart("muffleWarning")
[17:28:22.569]                       }
[17:28:22.569]                       else if (inherits(cond, "condition")) {
[17:28:22.569]                         if (!is.null(pattern)) {
[17:28:22.569]                           computeRestarts <- base::computeRestarts
[17:28:22.569]                           grepl <- base::grepl
[17:28:22.569]                           restarts <- computeRestarts(cond)
[17:28:22.569]                           for (restart in restarts) {
[17:28:22.569]                             name <- restart$name
[17:28:22.569]                             if (is.null(name)) 
[17:28:22.569]                               next
[17:28:22.569]                             if (!grepl(pattern, name)) 
[17:28:22.569]                               next
[17:28:22.569]                             invokeRestart(restart)
[17:28:22.569]                             muffled <- TRUE
[17:28:22.569]                             break
[17:28:22.569]                           }
[17:28:22.569]                         }
[17:28:22.569]                       }
[17:28:22.569]                       invisible(muffled)
[17:28:22.569]                     }
[17:28:22.569]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.569]                   }
[17:28:22.569]                 }
[17:28:22.569]                 else {
[17:28:22.569]                   if (TRUE) {
[17:28:22.569]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:22.569]                     {
[17:28:22.569]                       inherits <- base::inherits
[17:28:22.569]                       invokeRestart <- base::invokeRestart
[17:28:22.569]                       is.null <- base::is.null
[17:28:22.569]                       muffled <- FALSE
[17:28:22.569]                       if (inherits(cond, "message")) {
[17:28:22.569]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:22.569]                         if (muffled) 
[17:28:22.569]                           invokeRestart("muffleMessage")
[17:28:22.569]                       }
[17:28:22.569]                       else if (inherits(cond, "warning")) {
[17:28:22.569]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:22.569]                         if (muffled) 
[17:28:22.569]                           invokeRestart("muffleWarning")
[17:28:22.569]                       }
[17:28:22.569]                       else if (inherits(cond, "condition")) {
[17:28:22.569]                         if (!is.null(pattern)) {
[17:28:22.569]                           computeRestarts <- base::computeRestarts
[17:28:22.569]                           grepl <- base::grepl
[17:28:22.569]                           restarts <- computeRestarts(cond)
[17:28:22.569]                           for (restart in restarts) {
[17:28:22.569]                             name <- restart$name
[17:28:22.569]                             if (is.null(name)) 
[17:28:22.569]                               next
[17:28:22.569]                             if (!grepl(pattern, name)) 
[17:28:22.569]                               next
[17:28:22.569]                             invokeRestart(restart)
[17:28:22.569]                             muffled <- TRUE
[17:28:22.569]                             break
[17:28:22.569]                           }
[17:28:22.569]                         }
[17:28:22.569]                       }
[17:28:22.569]                       invisible(muffled)
[17:28:22.569]                     }
[17:28:22.569]                     muffleCondition(cond, pattern = "^muffle")
[17:28:22.569]                   }
[17:28:22.569]                 }
[17:28:22.569]             }
[17:28:22.569]         }))
[17:28:22.569]     }, error = function(ex) {
[17:28:22.569]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:22.569]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:22.569]                 ...future.rng), started = ...future.startTime, 
[17:28:22.569]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:22.569]             version = "1.8"), class = "FutureResult")
[17:28:22.569]     }, finally = {
[17:28:22.569]         if (!identical(...future.workdir, getwd())) 
[17:28:22.569]             setwd(...future.workdir)
[17:28:22.569]         {
[17:28:22.569]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:22.569]                 ...future.oldOptions$nwarnings <- NULL
[17:28:22.569]             }
[17:28:22.569]             base::options(...future.oldOptions)
[17:28:22.569]             if (.Platform$OS.type == "windows") {
[17:28:22.569]                 old_names <- names(...future.oldEnvVars)
[17:28:22.569]                 envs <- base::Sys.getenv()
[17:28:22.569]                 names <- names(envs)
[17:28:22.569]                 common <- intersect(names, old_names)
[17:28:22.569]                 added <- setdiff(names, old_names)
[17:28:22.569]                 removed <- setdiff(old_names, names)
[17:28:22.569]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:22.569]                   envs[common]]
[17:28:22.569]                 NAMES <- toupper(changed)
[17:28:22.569]                 args <- list()
[17:28:22.569]                 for (kk in seq_along(NAMES)) {
[17:28:22.569]                   name <- changed[[kk]]
[17:28:22.569]                   NAME <- NAMES[[kk]]
[17:28:22.569]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.569]                     next
[17:28:22.569]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.569]                 }
[17:28:22.569]                 NAMES <- toupper(added)
[17:28:22.569]                 for (kk in seq_along(NAMES)) {
[17:28:22.569]                   name <- added[[kk]]
[17:28:22.569]                   NAME <- NAMES[[kk]]
[17:28:22.569]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.569]                     next
[17:28:22.569]                   args[[name]] <- ""
[17:28:22.569]                 }
[17:28:22.569]                 NAMES <- toupper(removed)
[17:28:22.569]                 for (kk in seq_along(NAMES)) {
[17:28:22.569]                   name <- removed[[kk]]
[17:28:22.569]                   NAME <- NAMES[[kk]]
[17:28:22.569]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:22.569]                     next
[17:28:22.569]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:22.569]                 }
[17:28:22.569]                 if (length(args) > 0) 
[17:28:22.569]                   base::do.call(base::Sys.setenv, args = args)
[17:28:22.569]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:22.569]             }
[17:28:22.569]             else {
[17:28:22.569]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:22.569]             }
[17:28:22.569]             {
[17:28:22.569]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:22.569]                   0L) {
[17:28:22.569]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:22.569]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:22.569]                   base::options(opts)
[17:28:22.569]                 }
[17:28:22.569]                 {
[17:28:22.569]                   {
[17:28:22.569]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:22.569]                     NULL
[17:28:22.569]                   }
[17:28:22.569]                   options(future.plan = NULL)
[17:28:22.569]                   if (is.na(NA_character_)) 
[17:28:22.569]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:22.569]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:22.569]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:22.569]                     .init = FALSE)
[17:28:22.569]                 }
[17:28:22.569]             }
[17:28:22.569]         }
[17:28:22.569]     })
[17:28:22.569]     if (TRUE) {
[17:28:22.569]         base::sink(type = "output", split = FALSE)
[17:28:22.569]         if (TRUE) {
[17:28:22.569]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:22.569]         }
[17:28:22.569]         else {
[17:28:22.569]             ...future.result["stdout"] <- base::list(NULL)
[17:28:22.569]         }
[17:28:22.569]         base::close(...future.stdout)
[17:28:22.569]         ...future.stdout <- NULL
[17:28:22.569]     }
[17:28:22.569]     ...future.result$conditions <- ...future.conditions
[17:28:22.569]     ...future.result$finished <- base::Sys.time()
[17:28:22.569]     ...future.result
[17:28:22.569] }
[17:28:22.574] Poll #1 (0): usedNodes() = 2, workers = 2
[17:28:22.586] receiveMessageFromWorker() for ClusterFuture ...
[17:28:22.586] - Validating connection of MultisessionFuture
[17:28:22.586] - received message: FutureResult
[17:28:22.586] - Received FutureResult
[17:28:22.586] - Erased future from FutureRegistry
[17:28:22.587] result() for ClusterFuture ...
[17:28:22.587] - result already collected: FutureResult
[17:28:22.587] result() for ClusterFuture ... done
[17:28:22.587] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:22.587] result() for ClusterFuture ...
[17:28:22.587] - result already collected: FutureResult
[17:28:22.588] result() for ClusterFuture ... done
[17:28:22.588] result() for ClusterFuture ...
[17:28:22.588] - result already collected: FutureResult
[17:28:22.588] result() for ClusterFuture ... done
[17:28:22.589] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[17:28:22.589] Exporting 'x' (64 bytes) to cluster node #2 ...
[17:28:22.589] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[17:28:22.590] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[17:28:22.590] MultisessionFuture started
[17:28:22.591] - Launch lazy future ... done
[17:28:22.591] run() for 'MultisessionFuture' ... done
[17:28:22.591] result() for ClusterFuture ...
[17:28:22.591] - result already collected: FutureResult
[17:28:22.591] result() for ClusterFuture ... done
[17:28:22.591] result() for ClusterFuture ...
[17:28:22.592] - result already collected: FutureResult
[17:28:22.592] result() for ClusterFuture ... done
[17:28:22.592] result() for ClusterFuture ...
[17:28:22.592] - result already collected: FutureResult
[17:28:22.592] result() for ClusterFuture ... done
[17:28:22.592] result() for ClusterFuture ...
[17:28:22.593] - result already collected: FutureResult
[17:28:22.593] result() for ClusterFuture ... done
[17:28:22.593] result() for ClusterFuture ...
[17:28:22.593] receiveMessageFromWorker() for ClusterFuture ...
[17:28:22.593] - Validating connection of MultisessionFuture
[17:28:22.594] - received message: FutureResult
[17:28:22.594] - Received FutureResult
[17:28:22.594] - Erased future from FutureRegistry
[17:28:22.594] result() for ClusterFuture ...
[17:28:22.594] - result already collected: FutureResult
[17:28:22.594] result() for ClusterFuture ... done
[17:28:22.595] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:22.595] result() for ClusterFuture ... done
[17:28:22.595] result() for ClusterFuture ...
[17:28:22.595] - result already collected: FutureResult
[17:28:22.595] result() for ClusterFuture ... done
[17:28:22.595] result() for ClusterFuture ...
[17:28:22.596] receiveMessageFromWorker() for ClusterFuture ...
[17:28:22.596] - Validating connection of MultisessionFuture
[17:28:22.605] - received message: FutureResult
[17:28:22.605] - Received FutureResult
[17:28:22.606] - Erased future from FutureRegistry
[17:28:22.606] result() for ClusterFuture ...
[17:28:22.606] - result already collected: FutureResult
[17:28:22.606] result() for ClusterFuture ... done
[17:28:22.606] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:22.606] result() for ClusterFuture ... done
[17:28:22.606] result() for ClusterFuture ...
[17:28:22.607] - result already collected: FutureResult
[17:28:22.607] result() for ClusterFuture ... done
[[1]]
[1] 0

[[2]]
[1] 3

[[3]]
[1] 2

[[4]]
[1] 2

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.01622915 secs (started 2024-03-26 17:28:22.630535)
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.01387596 secs (started 2024-03-26 17:28:22.66489)
version: 1.8
<simpleError in log("a"): non-numeric argument to mathematical function>
> 
> stopifnot(identical(RNGkind(), okind))
> 
> message("*** rng ... DONE")
*** rng ... DONE
> 
> source("incl/end.R")
Failed to undo environment variables:
 - Expected environment variables: [n=204] '!ExitCode', 'ALLUSERSPROFILE', 'APPDATA', 'BIBINPUTS', 'BINDIR', 'BSTINPUTS', 'COMMONPROGRAMFILES', 'COMPUTERNAME', 'COMSPEC', 'CURL_CA_BUNDLE', 'CYGWIN', 'CommonProgramFiles(x86)', 'CommonProgramW6432', 'DriverData', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'JAGS_ROOT', 'JAVA_HOME', 'LANGUAGE', 'LC_COLLATE', 'LC_MONETARY', 'LC_TIME', 'LOCALAPPDATA', 'LOGONSERVER', 'LS_HOME', 'LS_LICENSE_PATH', 'MAKE', 'MAKEFLAGS', 'MAKELEVEL', 'MFLAGS', 'MSMPI_BENCHMARKS', 'MSMPI_BIN', 'MSYS2_ENV_CONV_EXCL', 'NUMBER_OF_PROCESSORS', 'OCL', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RTOOLS43_HOME', '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_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 
   4.21    0.17    6.04