Running 'DEPRECATED.R' [1s/1s]
  Running 'cluster-missing-doFuture-pkg.R' [1s/4s]
  Running 'doRNG,dopar.R' [3s/9s]
  Running 'doRNG,dorng.R' [7s/15s]
  Running 'foreach,errors.R' [2s/7s]
  Running 'foreach,globals.R' [9s/27s]
  Running 'foreach,nested.R' [9s/32s]
  Running 'foreach,nested_dopar.R' [18s/56s]
  Running 'foreach.R' [3s/8s]
  Running 'future.BatchJobs.R' [1s/1s]
  Running 'future.batchtools.R' [1s/1s]
  Running 'options.R' [3s/7s]
  Running 'registerDoFuture.R' [2s/7s]
  Running 'times.R' [3s/9s]
  Running 'zzz_opt-in,NMF.R' [0s/1s]
  Running 'zzz_opt-in,TSP.R' [0s/0s]
  Running 'zzz_opt-in,caret.R' [0s/1s]
  Running 'zzz_opt-in,foreach.R' [0s/1s]
  Running 'zzz_opt-in,glmnet.R' [0s/1s]
  Running 'zzz_opt-in,plyr.R' [0s/1s]
Running the tests in 'tests/foreach,errors.R' failed.
Complete output:
  > source("incl/start.R")
  Loading required package: globals
  Loading required package: future
  Loading required package: foreach
  Loading required package: iterators
  Loading required package: parallel
  [22:51:42.886] plan(): Setting new future strategy stack:
  [22:51:42.887] List of future strategies:
  [22:51:42.887] 1. sequential:
  [22:51:42.887]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:51:42.887]    - tweaked: FALSE
  [22:51:42.887]    - call: future::plan(future::sequential)
  [22:51:42.889] plan(): nbrOfWorkers() = 1
  > 
  > strategies <- future:::supportedStrategies()
  > strategies <- setdiff(strategies, "multiprocess")
  > 
  > message("*** doFuture() - error handling w/ 'stop' ...")
  *** doFuture() - error handling w/ 'stop' ...
  > 
  > for (strategy in strategies) {
  +   message(sprintf("- plan('%s') ...", strategy))
  +   plan(strategy)
  + 
  +   mu <- 1.0
  +   sigma <- 2.0
  + 
  +   res <- tryCatch({
  +     foreach(i = 1:10, .errorhandling = "stop") %dopar% {
  +       if (i %% 2 == 0) stop(sprintf("Index error ('stop'), because i = %d", i))
  +       dnorm(i, mean = mu, sd = sigma)
  +     }
  +   }, error = identity)
  +   print(res)
  +   stopifnot(inherits(res, "error"),
  +             grepl("Index error", conditionMessage(res)))
  + 
  +   message(sprintf("- plan('%s') ... DONE", strategy))
  + } ## for (strategy ...)
  - plan('sequential') ...
  [22:51:42.934] plan(): Setting new future strategy stack:
  [22:51:42.934] List of future strategies:
  [22:51:42.934] 1. sequential:
  [22:51:42.934]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:51:42.934]    - tweaked: FALSE
  [22:51:42.934]    - call: plan(strategy)
  [22:51:42.970] plan(): nbrOfWorkers() = 1
  [22:51:42.971] doFuture() ...
  [22:51:42.975] - dummy globals (as locals): [1] 'i'
  [22:51:42.977] - R expression:
  [22:51:42.977] {
  [22:51:42.977]     doFuture::registerDoFuture()
  [22:51:42.977]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [22:51:42.977]         ...future.x_jj <- ...future.x_ii[[jj]]
  [22:51:42.977]         i <- NULL
  [22:51:42.977]         ...future.env <- environment()
  [22:51:42.977]         local({
  [22:51:42.977]             for (name in names(...future.x_jj)) {
  [22:51:42.977]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [22:51:42.977]                   inherits = FALSE)
  [22:51:42.977]             }
  [22:51:42.977]         })
  [22:51:42.977]         tryCatch({
  [22:51:42.977]             if (i%%2 == 0) 
  [22:51:42.977]                 stop(sprintf("Index error ('stop'), because i = %d", 
  [22:51:42.977]                   i))
  [22:51:42.977]             dnorm(i, mean = mu, sd = sigma)
  [22:51:42.977]         }, error = identity)
  [22:51:42.977]     })
  [22:51:42.977] }
  [22:51:42.978] - identifying globals and packages ...
  [22:51:42.981] getGlobalsAndPackages() ...
  [22:51:42.981] Searching for globals...
  [22:51:43.017] - globals found: [22] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'if', '==', '%%', 'stop', 'sprintf', 'dnorm', 'mu', 'sigma', 'identity'
  [22:51:43.017] Searching for globals ... DONE
  [22:51:43.018] Resolving globals: FALSE
  [22:51:43.021] The total size of the 3 globals is 112 bytes (112 bytes)
  [22:51:43.022] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [22:51:43.024] - packages: [1] 'stats'
  [22:51:43.029] getGlobalsAndPackages() ... DONE
  [22:51:43.029] List of 3
  [22:51:43.029]  $ ...future.x_ii: NULL
  [22:51:43.029]  $ mu            : num 1
  [22:51:43.029]  $ sigma         : num 2
  [22:51:43.029]  - attr(*, "where")=List of 3
  [22:51:43.029]   ..$ ...future.x_ii:<environment: 0x2b22870> 
  [22:51:43.029]   ..$ mu            :<environment: R_GlobalEnv> 
  [22:51:43.029]   ..$ sigma         :<environment: R_GlobalEnv> 
  [22:51:43.029]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:51:43.029]  - attr(*, "resolved")= logi FALSE
  [22:51:43.029]  - attr(*, "total_size")= num 112
  [22:51:43.047]   - R expression:
  [22:51:43.047] {
  [22:51:43.047]     doFuture::registerDoFuture()
  [22:51:43.047]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [22:51:43.047]         ...future.x_jj <- ...future.x_ii[[jj]]
  [22:51:43.047]         i <- NULL
  [22:51:43.047]         ...future.env <- environment()
  [22:51:43.047]         local({
  [22:51:43.047]             for (name in names(...future.x_jj)) {
  [22:51:43.047]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [22:51:43.047]                   inherits = FALSE)
  [22:51:43.047]             }
  [22:51:43.047]         })
  [22:51:43.047]         tryCatch({
  [22:51:43.047]             if (i%%2 == 0) 
  [22:51:43.047]                 stop(sprintf("Index error ('stop'), because i = %d", 
  [22:51:43.047]                   i))
  [22:51:43.047]             dnorm(i, mean = mu, sd = sigma)
  [22:51:43.047]         }, error = identity)
  [22:51:43.047]     })
  [22:51:43.047] }
  [22:51:43.048]   - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [22:51:43.048] List of 3
  [22:51:43.048]  $ ...future.x_ii: NULL
  [22:51:43.048]  $ mu            : num 1
  [22:51:43.048]  $ sigma         : num 2
  [22:51:43.048]  - attr(*, "where")=List of 3
  [22:51:43.048]   ..$ ...future.x_ii:<environment: 0x2b22870> 
  [22:51:43.048]   ..$ mu            :<environment: R_GlobalEnv> 
  [22:51:43.048]   ..$ sigma         :<environment: R_GlobalEnv> 
  [22:51:43.048]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:51:43.048]  - attr(*, "resolved")= logi FALSE
  [22:51:43.048]  - attr(*, "total_size")= num 112
  [22:51:43.060]   - packages: [2] 'doFuture', 'stats'
  [22:51:43.060] - identifying globals and packages ... DONE
  [22:51:43.061] Number of chunks: 1
  [22:51:43.062] Number of futures (= number of chunks): 1
  [22:51:43.063] Launching 1 futures (chunks) ...
  [22:51:43.064] Chunk #1 of 1 ...
  [22:51:43.064]  - Finding globals in 'args_list' chunk #1 ...
  [22:51:43.064] getGlobalsAndPackages() ...
  [22:51:43.065] Searching for globals...
  [22:51:43.067] 
  [22:51:43.067] Searching for globals ... DONE
  [22:51:43.067] - globals: [0] <none>
  [22:51:43.068] getGlobalsAndPackages() ... DONE
  [22:51:43.068] 
  [22:51:43.068] 
  [22:51:43.069]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [22:51:43.070] getGlobalsAndPackages() ...
  [22:51:43.070] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [22:51:43.071] Resolving globals: FALSE
  [22:51:43.072] The total size of the 3 globals is 672 bytes (672 bytes)
  [22:51:43.073] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [22:51:43.073] 
  [22:51:43.074] getGlobalsAndPackages() ... DONE
  [22:51:43.077] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [22:51:43.078] Packages needed by future strategies (n = 0): <none>
  [22:51:43.085] {
  [22:51:43.085]     {
  [22:51:43.085]         ...future.startTime <- base::Sys.time()
  [22:51:43.085]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [22:51:43.085]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:51:43.085]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [22:51:43.085]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:51:43.085]             future.resolve.recursive = NULL, width = 80L)
  [22:51:43.085]         {
  [22:51:43.085]             {
  [22:51:43.085]                 {
  [22:51:43.085]                   base::local({
  [22:51:43.085]                     has_future <- base::requireNamespace("future", 
  [22:51:43.085]                       quietly = TRUE)
  [22:51:43.085]                     version <- if (has_future) 
  [22:51:43.085]                       utils::packageVersion("future")
  [22:51:43.085]                     else NULL
  [22:51:43.085]                     if (!has_future || version < "1.8.0") {
  [22:51:43.085]                       info <- base::c(r_version = base::gsub("R version ", 
  [22:51:43.085]                         "", base::R.version$version.string), 
  [22:51:43.085]                         platform = base::sprintf("%s (%s-bit)", 
  [22:51:43.085]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [22:51:43.085]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [22:51:43.085]                           "release", "version")], collapse = " "), 
  [22:51:43.085]                         hostname = base::Sys.info()[["nodename"]])
  [22:51:43.085]                       info <- base::sprintf("%s: %s", base::names(info), 
  [22:51:43.085]                         info)
  [22:51:43.085]                       info <- base::paste(info, collapse = "; ")
  [22:51:43.085]                       if (!has_future) {
  [22:51:43.085]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [22:51:43.085]                           info)
  [22:51:43.085]                       }
  [22:51:43.085]                       else {
  [22:51:43.085]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:51:43.085]                           info, version)
  [22:51:43.085]                       }
  [22:51:43.085]                       base::stop(msg)
  [22:51:43.085]                     }
  [22:51:43.085]                   })
  [22:51:43.085]                 }
  [22:51:43.085]                 base::local({
  [22:51:43.085]                   for (pkg in c("doFuture", "stats")) {
  [22:51:43.085]                     base::loadNamespace(pkg)
  [22:51:43.085]                     base::library(pkg, character.only = TRUE)
  [22:51:43.085]                   }
  [22:51:43.085]                 })
  [22:51:43.085]             }
  [22:51:43.085]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:51:43.085]         }
  [22:51:43.085]     }
  [22:51:43.085]     if (base::is.na(TRUE)) {
  [22:51:43.085]     }
  [22:51:43.085]     else {
  [22:51:43.085]         if (TRUE) {
  [22:51:43.085]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [22:51:43.085]                 open = "w")
  [22:51:43.085]         }
  [22:51:43.085]         else {
  [22:51:43.085]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [22:51:43.085]                 windows = "NUL", "/dev/null"), open = "w")
  [22:51:43.085]         }
  [22:51:43.085]         base::sink(...future.stdout, type = "output", split = FALSE)
  [22:51:43.085]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [22:51:43.085]             base::sink(type = "output", split = FALSE)
  [22:51:43.085]             base::close(...future.stdout)
  [22:51:43.085]         }, add = TRUE)
  [22:51:43.085]     }
  [22:51:43.085]     ...future.frame <- base::sys.nframe()
  [22:51:43.085]     ...future.conditions <- base::list()
  [22:51:43.085]     ...future.rng <- base::globalenv()$.Random.seed
  [22:51:43.085]     ...future.result <- base::tryCatch({
  [22:51:43.085]         base::withCallingHandlers({
  [22:51:43.085]             ...future.value <- base::withVisible(base::local({
  [22:51:43.085]                 doFuture::registerDoFuture()
  [22:51:43.085]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [22:51:43.085]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [22:51:43.085]                   i <- NULL
  [22:51:43.085]                   ...future.env <- environment()
  [22:51:43.085]                   local({
  [22:51:43.085]                     for (name in names(...future.x_jj)) {
  [22:51:43.085]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [22:51:43.085]                         inherits = FALSE)
  [22:51:43.085]                     }
  [22:51:43.085]                   })
  [22:51:43.085]                   tryCatch({
  [22:51:43.085]                     if (i%%2 == 0) 
  [22:51:43.085]                       stop(sprintf("Index error ('stop'), because i = %d", 
  [22:51:43.085]                         i))
  [22:51:43.085]                     dnorm(i, mean = mu, sd = sigma)
  [22:51:43.085]                   }, error = identity)
  [22:51:43.085]                 })
  [22:51:43.085]             }))
  [22:51:43.085]             future::FutureResult(value = ...future.value$value, 
  [22:51:43.085]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [22:51:43.085]                   ...future.rng), started = ...future.startTime, 
  [22:51:43.085]                 version = "1.8")
  [22:51:43.085]         }, condition = base::local({
  [22:51:43.085]             c <- base::c
  [22:51:43.085]             inherits <- base::inherits
  [22:51:43.085]             invokeRestart <- base::invokeRestart
  [22:51:43.085]             length <- base::length
  [22:51:43.085]             list <- base::list
  [22:51:43.085]             seq.int <- base::seq.int
  [22:51:43.085]             signalCondition <- base::signalCondition
  [22:51:43.085]             sys.calls <- base::sys.calls
  [22:51:43.085]             Sys.time <- base::Sys.time
  [22:51:43.085]             `[[` <- base::`[[`
  [22:51:43.085]             `+` <- base::`+`
  [22:51:43.085]             `<<-` <- base::`<<-`
  [22:51:43.085]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:51:43.085]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:51:43.085]                   3L)]
  [22:51:43.085]             }
  [22:51:43.085]             function(cond) {
  [22:51:43.085]                 if (inherits(cond, "error")) {
  [22:51:43.085]                   sessionInformation <- function() {
  [22:51:43.085]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [22:51:43.085]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [22:51:43.085]                       search = base::search(), system = base::Sys.info())
  [22:51:43.085]                   }
  [22:51:43.085]                   ...future.conditions[[length(...future.conditions) + 
  [22:51:43.085]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:51:43.085]                     cond$call), session = sessionInformation(), 
  [22:51:43.085]                     timestamp = Sys.time(), signaled = 0L)
  [22:51:43.085]                   signalCondition(cond)
  [22:51:43.085]                 }
  [22:51:43.085]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:51:43.085]                 ))) {
  [22:51:43.085]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:51:43.085]                   ...future.conditions[[length(...future.conditions) + 
  [22:51:43.085]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [22:51:43.085]                   if (!signal) {
  [22:51:43.085]                     muffleCondition <- function (cond) 
  [22:51:43.085]                     {
  [22:51:43.085]                       inherits <- base::inherits
  [22:51:43.085]                       invokeRestart <- base::invokeRestart
  [22:51:43.085]                       muffled <- FALSE
  [22:51:43.085]                       if (inherits(cond, "message")) {
  [22:51:43.085]                         invokeRestart("muffleMessage")
  [22:51:43.085]                         muffled <- TRUE
  [22:51:43.085]                       }
  [22:51:43.085]                       else if (inherits(cond, "warning")) {
  [22:51:43.085]                         invokeRestart("muffleWarning")
  [22:51:43.085]                         muffled <- TRUE
  [22:51:43.085]                       }
  [22:51:43.085]                       else if (inherits(cond, "condition")) {
  [22:51:43.085]                         computeRestarts <- base::computeRestarts
  [22:51:43.085]                         grepl <- base::grepl
  [22:51:43.085]                         is.null <- base::is.null
  [22:51:43.085]                         restarts <- computeRestarts(cond)
  [22:51:43.085]                         for (restart in restarts) {
  [22:51:43.085]                           name <- restart$name
  [22:51:43.085]                           if (is.null(name)) 
  [22:51:43.085]                             next
  [22:51:43.085]                           if (!grepl("^muffle", name)) 
  [22:51:43.085]                             next
  [22:51:43.085]                           invokeRestart(restart)
  [22:51:43.085]                           muffled <- TRUE
  [22:51:43.085]                           break
  [22:51:43.085]                         }
  [22:51:43.085]                       }
  [22:51:43.085]                       invisible(muffled)
  [22:51:43.085]                     }
  [22:51:43.085]                     muffleCondition(cond)
  [22:51:43.085]                   }
  [22:51:43.085]                 }
  [22:51:43.085]             }
  [22:51:43.085]         }))
  [22:51:43.085]     }, error = function(ex) {
  [22:51:43.085]         base::structure(base::list(value = NULL, visible = NULL, 
  [22:51:43.085]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [22:51:43.085]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [22:51:43.085]     }, finally = {
  [22:51:43.085]         {
  [22:51:43.085]             NULL
  [22:51:43.085]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:51:43.085]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:51:43.085]                 globals = TRUE, local = TRUE, earlySignal = FALSE, 
  [22:51:43.085]                 label = NULL, ...) 
  [22:51:43.085]             {
  [22:51:43.085]                 if (substitute) 
  [22:51:43.085]                   expr <- substitute(expr)
  [22:51:43.085]                 local <- as.logical(local)
  [22:51:43.085]                 future <- SequentialFuture(expr = expr, envir = envir, 
  [22:51:43.085]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:51:43.085]                   globals = globals, local = local, earlySignal = earlySignal, 
  [22:51:43.085]                   label = label, ...)
  [22:51:43.085]                 if (!future$lazy) 
  [22:51:43.085]                   future <- run(future)
  [22:51:43.085]                 invisible(future)
  [22:51:43.085]             }), .cleanup = FALSE, .init = FALSE)
  [22:51:43.085]         }
  [22:51:43.085]         base::options(...future.oldOptions)
  [22:51:43.085]     })
  [22:51:43.085]     Sys.time
  [22:51:43.085]     if (base::is.na(TRUE)) {
  [22:51:43.085]     }
  [22:51:43.085]     else {
  [22:51:43.085]         base::sink(type = "output", split = FALSE)
  [22:51:43.085]         if (TRUE) {
  [22:51:43.085]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [22:51:43.085]         }
  [22:51:43.085]         else {
  [22:51:43.085]             ...future.result["stdout"] <- base::list(NULL)
  [22:51:43.085]         }
  [22:51:43.085]         base::close(...future.stdout)
  [22:51:43.085]         ...future.stdout <- NULL
  [22:51:43.085]     }
  [22:51:43.085]     ...future.result$conditions <- ...future.conditions
  [22:51:43.085]     ...future.result
  [22:51:43.085] }
  [22:51:43.091] plan(): Setting new future strategy stack:
  [22:51:43.091] List of future strategies:
  [22:51:43.091] 1. sequential:
  [22:51:43.091]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:51:43.091]    - tweaked: FALSE
  [22:51:43.091]    - call: NULL
  [22:51:43.092] plan(): nbrOfWorkers() = 1
  [22:51:43.123] plan(): Setting new future strategy stack:
  [22:51:43.123] List of future strategies:
  [22:51:43.123] 1. sequential:
  [22:51:43.123]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:51:43.123]    - tweaked: FALSE
  [22:51:43.123]    - call: plan(strategy)
  [22:51:43.124] plan(): nbrOfWorkers() = 1
  [22:51:43.125] SequentialFuture started (and completed)
  [22:51:43.126] Chunk #1 of 1 ... DONE
  [22:51:43.127] Launching 1 futures (chunks) ... DONE
  [22:51:43.127] - resolving futures
  [22:51:43.127]   - gathering results & relaying conditions (except errors)
  [22:51:43.128] resolve() on list ...
  [22:51:43.129]  recursive: 0
  [22:51:43.129]  length: 1
  [22:51:43.130] 
  [22:51:43.130] Future #1
  [22:51:43.131] signalConditionsASAP(SequentialFuture, pos=1) ...
  [22:51:43.132] - nx: 1
  [22:51:43.132] - relay: TRUE
  [22:51:43.132] - stdout: TRUE
  [22:51:43.133] - signal: TRUE
  [22:51:43.133] - resignal: FALSE
  [22:51:43.133] - force: FALSE
  [22:51:43.133] - relayed: [n=1] FALSE
  [22:51:43.134] - queued futures: [n=1] FALSE
  [22:51:43.134]  - until=1
  [22:51:43.135]  - relaying element #1
  [22:51:43.135] - relayed: [n=1] TRUE
  [22:51:43.136] - queued futures: [n=1] TRUE
  [22:51:43.136] signalConditionsASAP(SequentialFuture, pos=1) ... done
  [22:51:43.137]  length: 0 (resolved future 1)
  [22:51:43.137] Relaying remaining futures
  [22:51:43.137] signalConditionsASAP(NULL, pos=0) ...
  [22:51:43.138] - nx: 1
  [22:51:43.138] - relay: TRUE
  [22:51:43.138] - stdout: TRUE
  [22:51:43.138] - signal: TRUE
  [22:51:43.139] - resignal: FALSE
  [22:51:43.139] - force: FALSE
  [22:51:43.139] - relayed: [n=1] TRUE
  [22:51:43.140] - queued futures: [n=1] TRUE
   - flush all
  [22:51:43.140] - relayed: [n=1] TRUE
  [22:51:43.141] - queued futures: [n=1] TRUE
  [22:51:43.141] signalConditionsASAP(NULL, pos=0) ... done
  [22:51:43.141] resolve() on list ... DONE
  [22:51:43.142] - collecting values of futures
  [22:51:43.142] - accumulating results
  [22:51:43.147] - processing errors (handler = 'stop')
  <simpleError in {    doFuture::registerDoFuture()    lapply(seq_along(...future.x_ii), FUN = function(jj) {        ...future.x_jj <- ...future.x_ii[[jj]]        i <- NULL        ...future.env <- environment()        local({            for (name in names(...future.x_jj)) {                assign(name, ...future.x_jj[[name]], envir = ...future.env,                   inherits = FALSE)            }        })        tryCatch({            if (i%%2 == 0)                 stop(sprintf("Index error ('stop'), because i = %d",                   i))            dnorm(i, mean = mu, sd = sigma)        }, error = identity)    })}: task 2 failed - "Index error ('stop'), because i = 2">
  - plan('sequential') ... DONE
  - plan('multicore') ...
  [22:51:43.149] plan(): Setting new future strategy stack:
  [22:51:43.149] List of future strategies:
  [22:51:43.149] 1. multicore:
  [22:51:43.149]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:51:43.149]    - tweaked: FALSE
  [22:51:43.149]    - call: plan(strategy)
  [22:51:43.178] plan(): nbrOfWorkers() = 2
  [22:51:43.179] doFuture() ...
  [22:51:43.181] - dummy globals (as locals): [1] 'i'
  [22:51:43.182] - R expression:
  [22:51:43.183] {
  [22:51:43.183]     doFuture::registerDoFuture()
  [22:51:43.183]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [22:51:43.183]         ...future.x_jj <- ...future.x_ii[[jj]]
  [22:51:43.183]         i <- NULL
  [22:51:43.183]         ...future.env <- environment()
  [22:51:43.183]         local({
  [22:51:43.183]             for (name in names(...future.x_jj)) {
  [22:51:43.183]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [22:51:43.183]                   inherits = FALSE)
  [22:51:43.183]             }
  [22:51:43.183]         })
  [22:51:43.183]         tryCatch({
  [22:51:43.183]             if (i%%2 == 0) 
  [22:51:43.183]                 stop(sprintf("Index error ('stop'), because i = %d", 
  [22:51:43.183]                   i))
  [22:51:43.183]             dnorm(i, mean = mu, sd = sigma)
  [22:51:43.183]         }, error = identity)
  [22:51:43.183]     })
  [22:51:43.183] }
  [22:51:43.183] - identifying globals and packages ...
  [22:51:43.184] getGlobalsAndPackages() ...
  [22:51:43.184] Searching for globals...
  [22:51:43.221] - globals found: [22] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'if', '==', '%%', 'stop', 'sprintf', 'dnorm', 'mu', 'sigma', 'identity'
  [22:51:43.221] Searching for globals ... DONE
  [22:51:43.222] Resolving globals: FALSE
  [22:51:43.240] The total size of the 3 globals is 112 bytes (112 bytes)
  [22:51:43.241] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [22:51:43.241] - packages: [1] 'stats'
  [22:51:43.242] getGlobalsAndPackages() ... DONE
  [22:51:43.242] List of 3
  [22:51:43.242]  $ ...future.x_ii: NULL
  [22:51:43.242]  $ mu            : num 1
  [22:51:43.242]  $ sigma         : num 2
  [22:51:43.242]  - attr(*, "where")=List of 3
  [22:51:43.242]   ..$ ...future.x_ii:<environment: 0xd7a320> 
  [22:51:43.242]   ..$ mu            :<environment: R_GlobalEnv> 
  [22:51:43.242]   ..$ sigma         :<environment: R_GlobalEnv> 
  [22:51:43.242]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:51:43.242]  - attr(*, "resolved")= logi FALSE
  [22:51:43.242]  - attr(*, "total_size")= num 112
  [22:51:43.271]   - R expression:
  [22:51:43.271] {
  [22:51:43.271]     doFuture::registerDoFuture()
  [22:51:43.271]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [22:51:43.271]         ...future.x_jj <- ...future.x_ii[[jj]]
  [22:51:43.271]         i <- NULL
  [22:51:43.271]         ...future.env <- environment()
  [22:51:43.271]         local({
  [22:51:43.271]             for (name in names(...future.x_jj)) {
  [22:51:43.271]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [22:51:43.271]                   inherits = FALSE)
  [22:51:43.271]             }
  [22:51:43.271]         })
  [22:51:43.271]         tryCatch({
  [22:51:43.271]             if (i%%2 == 0) 
  [22:51:43.271]                 stop(sprintf("Index error ('stop'), because i = %d", 
  [22:51:43.271]                   i))
  [22:51:43.271]             dnorm(i, mean = mu, sd = sigma)
  [22:51:43.271]         }, error = identity)
  [22:51:43.271]     })
  [22:51:43.271] }
  [22:51:43.272]   - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [22:51:43.272] List of 3
  [22:51:43.272]  $ ...future.x_ii: NULL
  [22:51:43.272]  $ mu            : num 1
  [22:51:43.272]  $ sigma         : num 2
  [22:51:43.272]  - attr(*, "where")=List of 3
  [22:51:43.272]   ..$ ...future.x_ii:<environment: 0xd7a320> 
  [22:51:43.272]   ..$ mu            :<environment: R_GlobalEnv> 
  [22:51:43.272]   ..$ sigma         :<environment: R_GlobalEnv> 
  [22:51:43.272]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:51:43.272]  - attr(*, "resolved")= logi FALSE
  [22:51:43.272]  - attr(*, "total_size")= num 112
  [22:51:43.304]   - packages: [2] 'doFuture', 'stats'
  [22:51:43.304] - identifying globals and packages ... DONE
  [22:51:43.309] Number of chunks: 2
  [22:51:43.309] Number of futures (= number of chunks): 2
  [22:51:43.310] Launching 2 futures (chunks) ...
  [22:51:43.310] Chunk #1 of 2 ...
  [22:51:43.311]  - Finding globals in 'args_list' chunk #1 ...
  [22:51:43.311] getGlobalsAndPackages() ...
  [22:51:43.311] Searching for globals...
  [22:51:43.313] 
  [22:51:43.313] Searching for globals ... DONE
  [22:51:43.313] - globals: [0] <none>
  [22:51:43.314] getGlobalsAndPackages() ... DONE
  [22:51:43.314] 
  [22:51:43.314] 
  [22:51:43.315]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [22:51:43.316] getGlobalsAndPackages() ...
  [22:51:43.316] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [22:51:43.317] Resolving globals: FALSE
  [22:51:43.334] The total size of the 3 globals is 392 bytes (392 bytes)
  [22:51:43.335] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [22:51:43.335] 
  [22:51:43.336] getGlobalsAndPackages() ... DONE
  [22:51:43.339] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [22:51:43.340] Packages needed by future strategies (n = 0): <none>
  [22:51:43.347] {
  [22:51:43.347]     {
  [22:51:43.347]         ...future.startTime <- base::Sys.time()
  [22:51:43.347]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [22:51:43.347]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:51:43.347]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:51:43.347]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:51:43.347]             future.resolve.recursive = NULL, width = 80L)
  [22:51:43.347]         {
  [22:51:43.347]             {
  [22:51:43.347]                 {
  [22:51:43.347]                   {
  [22:51:43.347]                     base::local({
  [22:51:43.347]                       has_future <- base::requireNamespace("future", 
  [22:51:43.347]                         quietly = TRUE)
  [22:51:43.347]                       version <- if (has_future) 
  [22:51:43.347]                         utils::packageVersion("future")
  [22:51:43.347]                       else NULL
  [22:51:43.347]                       if (!has_future || version < "1.8.0") {
  [22:51:43.347]                         info <- base::c(r_version = base::gsub("R version ", 
  [22:51:43.347]                           "", base::R.version$version.string), 
  [22:51:43.347]                           platform = base::sprintf("%s (%s-bit)", 
  [22:51:43.347]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [22:51:43.347]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [22:51:43.347]                             "release", "version")], collapse = " "), 
  [22:51:43.347]                           hostname = base::Sys.info()[["nodename"]])
  [22:51:43.347]                         info <- base::sprintf("%s: %s", base::names(info), 
  [22:51:43.347]                           info)
  [22:51:43.347]                         info <- base::paste(info, collapse = "; ")
  [22:51:43.347]                         if (!has_future) {
  [22:51:43.347]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [22:51:43.347]                             info)
  [22:51:43.347]                         }
  [22:51:43.347]                         else {
  [22:51:43.347]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:51:43.347]                             info, version)
  [22:51:43.347]                         }
  [22:51:43.347]                         base::stop(msg)
  [22:51:43.347]                       }
  [22:51:43.347]                     })
  [22:51:43.347]                   }
  [22:51:43.347]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [22:51:43.347]                   base::options(mc.cores = 1L)
  [22:51:43.347]                 }
  [22:51:43.347]                 base::local({
  [22:51:43.347]                   for (pkg in c("doFuture", "stats")) {
  [22:51:43.347]                     base::loadNamespace(pkg)
  [22:51:43.347]                     base::library(pkg, character.only = TRUE)
  [22:51:43.347]                   }
  [22:51:43.347]                 })
  [22:51:43.347]             }
  [22:51:43.347]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:51:43.347]         }
  [22:51:43.347]     }
  [22:51:43.347]     if (base::is.na(TRUE)) {
  [22:51:43.347]     }
  [22:51:43.347]     else {
  [22:51:43.347]         if (TRUE) {
  [22:51:43.347]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [22:51:43.347]                 open = "w")
  [22:51:43.347]         }
  [22:51:43.347]         else {
  [22:51:43.347]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [22:51:43.347]                 windows = "NUL", "/dev/null"), open = "w")
  [22:51:43.347]         }
  [22:51:43.347]         base::sink(...future.stdout, type = "output", split = FALSE)
  [22:51:43.347]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [22:51:43.347]             base::sink(type = "output", split = FALSE)
  [22:51:43.347]             base::close(...future.stdout)
  [22:51:43.347]         }, add = TRUE)
  [22:51:43.347]     }
  [22:51:43.347]     ...future.frame <- base::sys.nframe()
  [22:51:43.347]     ...future.conditions <- base::list()
  [22:51:43.347]     ...future.rng <- base::globalenv()$.Random.seed
  [22:51:43.347]     ...future.result <- base::tryCatch({
  [22:51:43.347]         base::withCallingHandlers({
  [22:51:43.347]             ...future.value <- base::withVisible(base::local({
  [22:51:43.347]                 doFuture::registerDoFuture()
  [22:51:43.347]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [22:51:43.347]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [22:51:43.347]                   i <- NULL
  [22:51:43.347]                   ...future.env <- environment()
  [22:51:43.347]                   local({
  [22:51:43.347]                     for (name in names(...future.x_jj)) {
  [22:51:43.347]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [22:51:43.347]                         inherits = FALSE)
  [22:51:43.347]                     }
  [22:51:43.347]                   })
  [22:51:43.347]                   tryCatch({
  [22:51:43.347]                     if (i%%2 == 0) 
  [22:51:43.347]                       stop(sprintf("Index error ('stop'), because i = %d", 
  [22:51:43.347]                         i))
  [22:51:43.347]                     dnorm(i, mean = mu, sd = sigma)
  [22:51:43.347]                   }, error = identity)
  [22:51:43.347]                 })
  [22:51:43.347]             }))
  [22:51:43.347]             future::FutureResult(value = ...future.value$value, 
  [22:51:43.347]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [22:51:43.347]                   ...future.rng), started = ...future.startTime, 
  [22:51:43.347]                 version = "1.8")
  [22:51:43.347]         }, condition = base::local({
  [22:51:43.347]             c <- base::c
  [22:51:43.347]             inherits <- base::inherits
  [22:51:43.347]             invokeRestart <- base::invokeRestart
  [22:51:43.347]             length <- base::length
  [22:51:43.347]             list <- base::list
  [22:51:43.347]             seq.int <- base::seq.int
  [22:51:43.347]             signalCondition <- base::signalCondition
  [22:51:43.347]             sys.calls <- base::sys.calls
  [22:51:43.347]             Sys.time <- base::Sys.time
  [22:51:43.347]             `[[` <- base::`[[`
  [22:51:43.347]             `+` <- base::`+`
  [22:51:43.347]             `<<-` <- base::`<<-`
  [22:51:43.347]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:51:43.347]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:51:43.347]                   3L)]
  [22:51:43.347]             }
  [22:51:43.347]             function(cond) {
  [22:51:43.347]                 if (inherits(cond, "error")) {
  [22:51:43.347]                   sessionInformation <- function() {
  [22:51:43.347]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [22:51:43.347]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [22:51:43.347]                       search = base::search(), system = base::Sys.info())
  [22:51:43.347]                   }
  [22:51:43.347]                   ...future.conditions[[length(...future.conditions) + 
  [22:51:43.347]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:51:43.347]                     cond$call), session = sessionInformation(), 
  [22:51:43.347]                     timestamp = Sys.time(), signaled = 0L)
  [22:51:43.347]                   signalCondition(cond)
  [22:51:43.347]                 }
  [22:51:43.347]                 else if (inherits(cond, "condition")) {
  [22:51:43.347]                   signal <- FALSE && inherits(cond, character(0))
  [22:51:43.347]                   ...future.conditions[[length(...future.conditions) + 
  [22:51:43.347]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [22:51:43.347]                   if (!signal) {
  [22:51:43.347]                     muffleCondition <- function (cond) 
  [22:51:43.347]                     {
  [22:51:43.347]                       inherits <- base::inherits
  [22:51:43.347]                       invokeRestart <- base::invokeRestart
  [22:51:43.347]                       muffled <- FALSE
  [22:51:43.347]                       if (inherits(cond, "message")) {
  [22:51:43.347]                         invokeRestart("muffleMessage")
  [22:51:43.347]                         muffled <- TRUE
  [22:51:43.347]                       }
  [22:51:43.347]                       else if (inherits(cond, "warning")) {
  [22:51:43.347]                         invokeRestart("muffleWarning")
  [22:51:43.347]                         muffled <- TRUE
  [22:51:43.347]                       }
  [22:51:43.347]                       else if (inherits(cond, "condition")) {
  [22:51:43.347]                         computeRestarts <- base::computeRestarts
  [22:51:43.347]                         grepl <- base::grepl
  [22:51:43.347]                         is.null <- base::is.null
  [22:51:43.347]                         restarts <- computeRestarts(cond)
  [22:51:43.347]                         for (restart in restarts) {
  [22:51:43.347]                           name <- restart$name
  [22:51:43.347]                           if (is.null(name)) 
  [22:51:43.347]                             next
  [22:51:43.347]                           if (!grepl("^muffle", name)) 
  [22:51:43.347]                             next
  [22:51:43.347]                           invokeRestart(restart)
  [22:51:43.347]                           muffled <- TRUE
  [22:51:43.347]                           break
  [22:51:43.347]                         }
  [22:51:43.347]                       }
  [22:51:43.347]                       invisible(muffled)
  [22:51:43.347]                     }
  [22:51:43.347]                     muffleCondition(cond)
  [22:51:43.347]                   }
  [22:51:43.347]                 }
  [22:51:43.347]             }
  [22:51:43.347]         }))
  [22:51:43.347]     }, error = function(ex) {
  [22:51:43.347]         base::structure(base::list(value = NULL, visible = NULL, 
  [22:51:43.347]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [22:51:43.347]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [22:51:43.347]     }, finally = {
  [22:51:43.347]         {
  [22:51:43.347]             {
  [22:51:43.347]                 base::options(mc.cores = ...future.mc.cores.old)
  [22:51:43.347]             }
  [22:51:43.347]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:51:43.347]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:51:43.347]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:51:43.347]                 earlySignal = FALSE, label = NULL, ...) 
  [22:51:43.347]             {
  [22:51:43.347]                 if (substitute) 
  [22:51:43.347]                   expr <- substitute(expr)
  [22:51:43.347]                 if (is.function(workers)) 
  [22:51:43.347]                   workers <- workers()
  [22:51:43.347]                 workers <- as.integer(workers)
  [22:51:43.347]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:51:43.347]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:51:43.347]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:51:43.347]                     lazy = lazy, seed = seed, globals = globals, 
  [22:51:43.347]                     local = TRUE, label = label, ...))
  [22:51:43.347]                 }
  [22:51:43.347]                 oopts <- options(mc.cores = workers)
  [22:51:43.347]                 on.exit(options(oopts))
  [22:51:43.347]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:51:43.347]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:51:43.347]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:51:43.347]                   label = label, ...)
  [22:51:43.347]                 if (!future$lazy) 
  [22:51:43.347]                   future <- run(future)
  [22:51:43.347]                 invisible(future)
  [22:51:43.347]             }), .cleanup = FALSE, .init = FALSE)
  [22:51:43.347]         }
  [22:51:43.347]         base::options(...future.oldOptions)
  [22:51:43.347]     })
  [22:51:43.347]     Sys.time
  [22:51:43.347]     if (base::is.na(TRUE)) {
  [22:51:43.347]     }
  [22:51:43.347]     else {
  [22:51:43.347]         base::sink(type = "output", split = FALSE)
  [22:51:43.347]         if (TRUE) {
  [22:51:43.347]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [22:51:43.347]         }
  [22:51:43.347]         else {
  [22:51:43.347]             ...future.result["stdout"] <- base::list(NULL)
  [22:51:43.347]         }
  [22:51:43.347]         base::close(...future.stdout)
  [22:51:43.347]         ...future.stdout <- NULL
  [22:51:43.347]     }
  [22:51:43.347]     ...future.result$conditions <- ...future.conditions
  [22:51:43.347]     ...future.result
  [22:51:43.347] }
  [22:51:43.350] requestCore(): workers = 2
  [22:51:43.356] MulticoreFuture started
  [22:51:43.357] Chunk #1 of 2 ... DONE
  [22:51:43.358] Chunk #2 of 2 ...
  [22:51:43.358]  - Finding globals in 'args_list' chunk #2 ...
  [22:51:43.359] getGlobalsAndPackages() ...
  [22:51:43.359] Searching for globals...
  [22:51:43.361] 
  [22:51:43.362] Searching for globals ... DONE
  [22:51:43.362] - globals: [0] <none>
  [22:51:43.363] getGlobalsAndPackages() ... DONE
  [22:51:43.363] 
  [22:51:43.364] 
  [22:51:43.364]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [22:51:43.366] getGlobalsAndPackages() ...
  [22:51:43.367] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [22:51:43.368] Resolving globals: FALSE
  [22:51:43.370] The total size of the 3 globals is 392 bytes (392 bytes)
  [22:51:43.371] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [22:51:43.371] 
  [22:51:43.372] getGlobalsAndPackages() ... DONE
  [22:51:43.373] plan(): Setting new future strategy stack:
  [22:51:43.374] List of future strategies:
  [22:51:43.374] 1. sequential:
  [22:51:43.374]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:51:43.374]    - tweaked: FALSE
  [22:51:43.374]    - call: NULL
  [22:51:43.376] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [22:51:43.376] Packages needed by future strategies (n = 0): <none>
  [22:51:43.376] plan(): nbrOfWorkers() = 1
  [22:51:43.380] plan(): Setting new future strategy stack:
  [22:51:43.380] List of future strategies:
  [22:51:43.380] 1. multicore:
  [22:51:43.380]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:51:43.380]    - tweaked: FALSE
  [22:51:43.380]    - call: plan(strategy)
  [22:51:43.386] {
  [22:51:43.386]     {
  [22:51:43.386]         ...future.startTime <- base::Sys.time()
  [22:51:43.386]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [22:51:43.386]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:51:43.386]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:51:43.386]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:51:43.386]             future.resolve.recursive = NULL, width = 80L)
  [22:51:43.386]         {
  [22:51:43.386]             {
  [22:51:43.386]                 {
  [22:51:43.386]                   {
  [22:51:43.386]                     base::local({
  [22:51:43.386]                       has_future <- base::requireNamespace("future", 
  [22:51:43.386]                         quietly = TRUE)
  [22:51:43.386]                       version <- if (has_future) 
  [22:51:43.386]                         utils::packageVersion("future")
  [22:51:43.386]                       else NULL
  [22:51:43.386]                       if (!has_future || version < "1.8.0") {
  [22:51:43.386]                         info <- base::c(r_version = base::gsub("R version ", 
  [22:51:43.386]                           "", base::R.version$version.string), 
  [22:51:43.386]                           platform = base::sprintf("%s (%s-bit)", 
  [22:51:43.386]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [22:51:43.386]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [22:51:43.386]                             "release", "version")], collapse = " "), 
  [22:51:43.386]                           hostname = base::Sys.info()[["nodename"]])
  [22:51:43.386]                         info <- base::sprintf("%s: %s", base::names(info), 
  [22:51:43.386]                           info)
  [22:51:43.386]                         info <- base::paste(info, collapse = "; ")
  [22:51:43.386]                         if (!has_future) {
  [22:51:43.386]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [22:51:43.386]                             info)
  [22:51:43.386]                         }
  [22:51:43.386]                         else {
  [22:51:43.386]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:51:43.386]                             info, version)
  [22:51:43.386]                         }
  [22:51:43.386]                         base::stop(msg)
  [22:51:43.386]                       }
  [22:51:43.386]                     })
  [22:51:43.386]                   }
  [22:51:43.386]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [22:51:43.386]                   base::options(mc.cores = 1L)
  [22:51:43.386]                 }
  [22:51:43.386]                 base::local({
  [22:51:43.386]                   for (pkg in c("doFuture", "stats")) {
  [22:51:43.386]                     base::loadNamespace(pkg)
  [22:51:43.386]                     base::library(pkg, character.only = TRUE)
  [22:51:43.386]                   }
  [22:51:43.386]                 })
  [22:51:43.386]             }
  [22:51:43.386]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:51:43.386]         }
  [22:51:43.386]     }
  [22:51:43.386]     if (base::is.na(TRUE)) {
  [22:51:43.386]     }
  [22:51:43.386]     else {
  [22:51:43.386]         if (TRUE) {
  [22:51:43.386]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [22:51:43.386]                 open = "w")
  [22:51:43.386]         }
  [22:51:43.386]         else {
  [22:51:43.386]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [22:51:43.386]                 windows = "NUL", "/dev/null"), open = "w")
  [22:51:43.386]         }
  [22:51:43.386]         base::sink(...future.stdout, type = "output", split = FALSE)
  [22:51:43.386]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [22:51:43.386]             base::sink(type = "output", split = FALSE)
  [22:51:43.386]             base::close(...future.stdout)
  [22:51:43.386]         }, add = TRUE)
  [22:51:43.386]     }
  [22:51:43.386]     ...future.frame <- base::sys.nframe()
  [22:51:43.386]     ...future.conditions <- base::list()
  [22:51:43.386]     ...future.rng <- base::globalenv()$.Random.seed
  [22:51:43.386]     ...future.result <- base::tryCatch({
  [22:51:43.386]         base::withCallingHandlers({
  [22:51:43.386]             ...future.value <- base::withVisible(base::local({
  [22:51:43.386]                 doFuture::registerDoFuture()
  [22:51:43.386]                 lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [22:51:43.386]                   ...future.x_jj <- ...future.x_ii[[jj]]
  [22:51:43.386]                   i <- NULL
  [22:51:43.386]                   ...future.env <- environment()
  [22:51:43.386]                   local({
  [22:51:43.386]                     for (name in names(...future.x_jj)) {
  [22:51:43.386]                       assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [22:51:43.386]                         inherits = FALSE)
  [22:51:43.386]                     }
  [22:51:43.386]                   })
  [22:51:43.386]                   tryCatch({
  [22:51:43.386]                     if (i%%2 == 0) 
  [22:51:43.386]                       stop(sprintf("Index error ('stop'), because i = %d", 
  [22:51:43.386]                         i))
  [22:51:43.386]                     dnorm(i, mean = mu, sd = sigma)
  [22:51:43.386]                   }, error = identity)
  [22:51:43.386]                 })
  [22:51:43.386]             }))
  [22:51:43.386]             future::FutureResult(value = ...future.value$value, 
  [22:51:43.386]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [22:51:43.386]                   ...future.rng), started = ...future.startTime, 
  [22:51:43.386]                 version = "1.8")
  [22:51:43.386]         }, condition = base::local({
  [22:51:43.386]             c <- base::c
  [22:51:43.386]             inherits <- base::inherits
  [22:51:43.386]             invokeRestart <- base::invokeRestart
  [22:51:43.386]             length <- base::length
  [22:51:43.386]             list <- base::list
  [22:51:43.386]             seq.int <- base::seq.int
  [22:51:43.386]             signalCondition <- base::signalCondition
  [22:51:43.386]             sys.calls <- base::sys.calls
  [22:51:43.386]             Sys.time <- base::Sys.time
  [22:51:43.386]             `[[` <- base::`[[`
  [22:51:43.386]             `+` <- base::`+`
  [22:51:43.386]             `<<-` <- base::`<<-`
  [22:51:43.386]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:51:43.386]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:51:43.386]                   3L)]
  [22:51:43.386]             }
  [22:51:43.386]             function(cond) {
  [22:51:43.386]                 if (inherits(cond, "error")) {
  [22:51:43.386]                   sessionInformation <- function() {
  [22:51:43.386]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [22:51:43.386]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [22:51:43.386]                       search = base::search(), system = base::Sys.info())
  [22:51:43.386]                   }
  [22:51:43.386]                   ...future.conditions[[length(...future.conditions) + 
  [22:51:43.386]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:51:43.386]                     cond$call), session = sessionInformation(), 
  [22:51:43.386]                     timestamp = Sys.time(), signaled = 0L)
  [22:51:43.386]                   signalCondition(cond)
  [22:51:43.386]                 }
  [22:51:43.386]                 else if (inherits(cond, "condition")) {
  [22:51:43.386]                   signal <- FALSE && inherits(cond, character(0))
  [22:51:43.386]                   ...future.conditions[[length(...future.conditions) + 
  [22:51:43.386]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [22:51:43.386]                   if (!signal) {
  [22:51:43.386]                     muffleCondition <- function (cond) 
  [22:51:43.386]                     {
  [22:51:43.386]                       inherits <- base::inherits
  [22:51:43.386]                       invokeRestart <- base::invokeRestart
  [22:51:43.386]                       muffled <- FALSE
  [22:51:43.386]                       if (inherits(cond, "message")) {
  [22:51:43.386]                         invokeRestart("muffleMessage")
  [22:51:43.386]                         muffled <- TRUE
  [22:51:43.386]                       }
  [22:51:43.386]                       else if (inherits(cond, "warning")) {
  [22:51:43.386]                         invokeRestart("muffleWarning")
  [22:51:43.386]                         muffled <- TRUE
  [22:51:43.386]                       }
  [22:51:43.386]                       else if (inherits(cond, "condition")) {
  [22:51:43.386]                         computeRestarts <- base::computeRestarts
  [22:51:43.386]                         grepl <- base::grepl
  [22:51:43.386]                         is.null <- base::is.null
  [22:51:43.386]                         restarts <- computeRestarts(cond)
  [22:51:43.386]                         for (restart in restarts) {
  [22:51:43.386]                           name <- restart$name
  [22:51:43.386]                           if (is.null(name)) 
  [22:51:43.386]                             next
  [22:51:43.386]                           if (!grepl("^muffle", name)) 
  [22:51:43.386]                             next
  [22:51:43.386]                           invokeRestart(restart)
  [22:51:43.386]                           muffled <- TRUE
  [22:51:43.386]                           break
  [22:51:43.386]                         }
  [22:51:43.386]                       }
  [22:51:43.386]                       invisible(muffled)
  [22:51:43.386]                     }
  [22:51:43.386]                     muffleCondition(cond)
  [22:51:43.386]                   }
  [22:51:43.386]                 }
  [22:51:43.386]             }
  [22:51:43.386]         }))
  [22:51:43.386]     }, error = function(ex) {
  [22:51:43.386]         base::structure(base::list(value = NULL, visible = NULL, 
  [22:51:43.386]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [22:51:43.386]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [22:51:43.386]     }, finally = {
  [22:51:43.386]         {
  [22:51:43.386]             {
  [22:51:43.386]                 base::options(mc.cores = ...future.mc.cores.old)
  [22:51:43.386]             }
  [22:51:43.386]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:51:43.386]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:51:43.386]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [22:51:43.386]                 earlySignal = FALSE, label = NULL, ...) 
  [22:51:43.386]             {
  [22:51:43.386]                 if (substitute) 
  [22:51:43.386]                   expr <- substitute(expr)
  [22:51:43.386]                 if (is.function(workers)) 
  [22:51:43.386]                   workers <- workers()
  [22:51:43.386]                 workers <- as.integer(workers)
  [22:51:43.386]                 stop_if_not(is.finite(workers), workers >= 1L)
  [22:51:43.386]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [22:51:43.386]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:51:43.386]                     lazy = lazy, seed = seed, globals = globals, 
  [22:51:43.386]                     local = TRUE, label = label, ...))
  [22:51:43.386]                 }
  [22:51:43.386]                 oopts <- options(mc.cores = workers)
  [22:51:43.386]                 on.exit(options(oopts))
  [22:51:43.386]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [22:51:43.386]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:51:43.386]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [22:51:43.386]                   label = label, ...)
  [22:51:43.386]                 if (!future$lazy) 
  [22:51:43.386]                   future <- run(future)
  [22:51:43.386]                 invisible(future)
  [22:51:43.386]             }), .cleanup = FALSE, .init = FALSE)
  [22:51:43.386]         }
  [22:51:43.386]         base::options(...future.oldOptions)
  [22:51:43.386]     })
  [22:51:43.386]     Sys.time
  [22:51:43.386]     if (base::is.na(TRUE)) {
  [22:51:43.386]     }
  [22:51:43.386]     else {
  [22:51:43.386]         base::sink(type = "output", split = FALSE)
  [22:51:43.386]         if (TRUE) {
  [22:51:43.386]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [22:51:43.386]         }
  [22:51:43.386]         else {
  [22:51:43.386]             ...future.result["stdout"] <- base::list(NULL)
  [22:51:43.386]         }
  [22:51:43.386]         base::close(...future.stdout)
  [22:51:43.386]         ...future.stdout <- NULL
  [22:51:43.386]     }
  [22:51:43.386]     ...future.result$conditions <- ...future.conditions
  [22:51:43.386]     ...future.result
  [22:51:43.386] }
  [22:51:43.390] requestCore(): workers = 2
  [22:51:43.399] plan(): nbrOfWorkers() = 2
  [22:51:43.404] MulticoreFuture started
  [22:51:43.406] Chunk #2 of 2 ... DONE
  [22:51:43.406] Launching 2 futures (chunks) ... DONE
  [22:51:43.407] - resolving futures
  [22:51:43.407]   - gathering results & relaying conditions (except errors)
  [22:51:43.408] resolve() on list ...
  [22:51:43.408]  recursive: 0
  [22:51:43.409]  length: 2
  [22:51:43.409] 
  [22:51:43.413] Future #1
  [22:51:43.425] signalConditionsASAP(MulticoreFuture, pos=1) ...
  [22:51:43.425] - nx: 2
  [22:51:43.426] - relay: TRUE
  [22:51:43.426] - stdout: TRUE
  [22:51:43.426] - signal: TRUE
  [22:51:43.427] - resignal: FALSE
  [22:51:43.427] - force: FALSE
  [22:51:43.428] - relayed: [n=2] FALSE, FALSE
  [22:51:43.428] - queued futures: [n=2] FALSE, FALSE
  [22:51:43.429]  - until=1
  [22:51:43.429]  - relaying element #1
  [22:51:43.430] - relayed: [n=2] TRUE, FALSE
  [22:51:43.430] - queued futures: [n=2] TRUE, FALSE
  [22:51:43.431] signalConditionsASAP(MulticoreFuture, pos=1) ... done
  [22:51:43.431]  length: 1 (resolved future 1)
  [22:51:43.437] plan(): Setting new future strategy stack:
  [22:51:43.438] List of future strategies:
  [22:51:43.438] 1. sequential:
  [22:51:43.438]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [22:51:43.438]    - tweaked: FALSE
  [22:51:43.438]    - call: NULL
  [22:51:43.448] plan(): nbrOfWorkers() = 1
  [22:51:43.451] plan(): Setting new future strategy stack:
  [22:51:43.451] List of future strategies:
  [22:51:43.451] 1. multicore:
  [22:51:43.451]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [22:51:43.451]    - tweaked: FALSE
  [22:51:43.451]    - call: plan(strategy)
  [22:51:43.453] plan(): nbrOfWorkers() = 2
  [22:51:43.454] Future #2
  [22:51:43.456] signalConditionsASAP(MulticoreFuture, pos=2) ...
  [22:51:43.457] - nx: 2
  [22:51:43.465] - relay: TRUE
  [22:51:43.466] - stdout: TRUE
  [22:51:43.466] - signal: TRUE
  [22:51:43.467] - resignal: FALSE
  [22:51:43.467] - force: FALSE
  [22:51:43.468] - relayed: [n=2] TRUE, FALSE
  [22:51:43.468] - queued futures: [n=2] TRUE, FALSE
  [22:51:43.469]  - until=2
  [22:51:43.469]  - relaying element #2
  [22:51:43.470] - relayed: [n=2] TRUE, TRUE
  [22:51:43.470] - queued futures: [n=2] TRUE, TRUE
  [22:51:43.471] signalConditionsASAP(MulticoreFuture, pos=2) ... done
  [22:51:43.471]  length: 0 (resolved future 2)
  [22:51:43.472] Relaying remaining futures
  [22:51:43.472] signalConditionsASAP(NULL, pos=0) ...
  [22:51:43.473] - nx: 2
  [22:51:43.473] - relay: TRUE
  [22:51:43.474] - stdout: TRUE
  [22:51:43.474] - signal: TRUE
  [22:51:43.474] - resignal: FALSE
  [22:51:43.475] - force: FALSE
  [22:51:43.475] - relayed: [n=2] TRUE, TRUE
  [22:51:43.475] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [22:51:43.476] - relayed: [n=2] TRUE, TRUE
  [22:51:43.476] - queued futures: [n=2] TRUE, TRUE
  [22:51:43.477] signalConditionsASAP(NULL, pos=0) ... done
  [22:51:43.477] resolve() on list ... DONE
  [22:51:43.478] - collecting values of futures
  [22:51:43.495] - accumulating results
  [22:51:43.498] - processing errors (handler = 'stop')
  <simpleError in {    doFuture::registerDoFuture()    lapply(seq_along(...future.x_ii), FUN = function(jj) {        ...future.x_jj <- ...future.x_ii[[jj]]        i <- NULL        ...future.env <- environment()        local({            for (name in names(...future.x_jj)) {                assign(name, ...future.x_jj[[name]], envir = ...future.env,                   inherits = FALSE)            }        })        tryCatch({            if (i%%2 == 0)                 stop(sprintf("Index error ('stop'), because i = %d",                   i))            dnorm(i, mean = mu, sd = sigma)        }, error = identity)    })}: task 2 failed - "Index error ('stop'), because i = 2">
  - plan('multicore') ... DONE
  - plan('multisession') ...
  [22:51:43.500] plan(): Setting new future strategy stack:
  [22:51:43.500] List of future strategies:
  [22:51:43.500] 1. multisession:
  [22:51:43.500]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:51:43.500]    - tweaked: FALSE
  [22:51:43.500]    - call: plan(strategy)
  [22:51:43.502] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [22:51:43.502] multisession:
  [22:51:43.502] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:51:43.502] - tweaked: FALSE
  [22:51:43.502] - call: plan(strategy)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 22653
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpLnkGbF/future.parent=16445.403d1ed85a09.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpLnkGbF/future.parent=16445.403d1ed85a09.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,errors.R:16445:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpLnkGbF/future.parent=16445.403d1ed85a09.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=22653 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  [local output] Connection with worker #1 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 1 of 2 ... done
  [local output] Creating node 2 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpLnkGbF/future.parent=16445.403d33137152.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpLnkGbF/future.parent=16445.403d33137152.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,errors.R:16445:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpLnkGbF/future.parent=16445.403d33137152.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=22653 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #2 on 'localhost' to connect back
  [local output] Connection with worker #2 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 2 of 2 ... done
  [22:51:46.269] getGlobalsAndPackages() ...
  [22:51:46.270] Not searching for globals
  [22:51:46.270] - globals: [0] <none>
  [22:51:46.271] getGlobalsAndPackages() ... DONE
  [22:51:46.277] Packages needed by the future expression (n = 0): <none>
  [22:51:46.277] Packages needed by future strategies (n = 0): <none>
  [22:51:46.284] {
  [22:51:46.284]     {
  [22:51:46.284]         ...future.startTime <- base::Sys.time()
  [22:51:46.284]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [22:51:46.284]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:51:46.284]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:51:46.284]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:51:46.284]             future.resolve.recursive = NULL, width = 80L)
  [22:51:46.284]         {
  [22:51:46.284]             {
  [22:51:46.284]                 {
  [22:51:46.284]                   base::local({
  [22:51:46.284]                     has_future <- base::requireNamespace("future", 
  [22:51:46.284]                       quietly = TRUE)
  [22:51:46.284]                     version <- if (has_future) 
  [22:51:46.284]                       utils::packageVersion("future")
  [22:51:46.284]                     else NULL
  [22:51:46.284]                     if (!has_future || version < "1.8.0") {
  [22:51:46.284]                       info <- base::c(r_version = base::gsub("R version ", 
  [22:51:46.284]                         "", base::R.version$version.string), 
  [22:51:46.284]                         platform = base::sprintf("%s (%s-bit)", 
  [22:51:46.284]                           base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [22:51:46.284]                         os = base::paste(base::Sys.info()[base::c("sysname", 
  [22:51:46.284]                           "release", "version")], collapse = " "), 
  [22:51:46.284]                         hostname = base::Sys.info()[["nodename"]])
  [22:51:46.284]                       info <- base::sprintf("%s: %s", base::names(info), 
  [22:51:46.284]                         info)
  [22:51:46.284]                       info <- base::paste(info, collapse = "; ")
  [22:51:46.284]                       if (!has_future) {
  [22:51:46.284]                         msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [22:51:46.284]                           info)
  [22:51:46.284]                       }
  [22:51:46.284]                       else {
  [22:51:46.284]                         msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:51:46.284]                           info, version)
  [22:51:46.284]                       }
  [22:51:46.284]                       base::stop(msg)
  [22:51:46.284]                     }
  [22:51:46.284]                   })
  [22:51:46.284]                 }
  [22:51:46.284]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [22:51:46.284]                 base::options(mc.cores = 1L)
  [22:51:46.284]             }
  [22:51:46.284]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:51:46.284]         }
  [22:51:46.284]     }
  [22:51:46.284]     if (base::is.na(TRUE)) {
  [22:51:46.284]     }
  [22:51:46.284]     else {
  [22:51:46.284]         if (TRUE) {
  [22:51:46.284]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [22:51:46.284]                 open = "w")
  [22:51:46.284]         }
  [22:51:46.284]         else {
  [22:51:46.284]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [22:51:46.284]                 windows = "NUL", "/dev/null"), open = "w")
  [22:51:46.284]         }
  [22:51:46.284]         base::sink(...future.stdout, type = "output", split = FALSE)
  [22:51:46.284]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [22:51:46.284]             base::sink(type = "output", split = FALSE)
  [22:51:46.284]             base::close(...future.stdout)
  [22:51:46.284]         }, add = TRUE)
  [22:51:46.284]     }
  [22:51:46.284]     ...future.frame <- base::sys.nframe()
  [22:51:46.284]     ...future.conditions <- base::list()
  [22:51:46.284]     ...future.rng <- base::globalenv()$.Random.seed
  [22:51:46.284]     ...future.result <- base::tryCatch({
  [22:51:46.284]         base::withCallingHandlers({
  [22:51:46.284]             ...future.value <- base::withVisible(base::local({
  [22:51:46.284]                 ...future.sendCondition <- local({
  [22:51:46.284]                   sendCondition <- NULL
  [22:51:46.284]                   function(frame = 1L) {
  [22:51:46.284]                     if (is.function(sendCondition)) 
  [22:51:46.284]                       return(sendCondition)
  [22:51:46.284]                     ns <- getNamespace("parallel")
  [22:51:46.284]                     if (exists("sendData", mode = "function", 
  [22:51:46.284]                       envir = ns)) {
  [22:51:46.284]                       parallel_sendData <- get("sendData", mode = "function", 
  [22:51:46.284]                         envir = ns)
  [22:51:46.284]                       envir <- sys.frame(frame)
  [22:51:46.284]                       master <- NULL
  [22:51:46.284]                       while (!identical(envir, .GlobalEnv) && 
  [22:51:46.284]                         !identical(envir, emptyenv())) {
  [22:51:46.284]                         if (exists("master", mode = "list", envir = envir, 
  [22:51:46.284]                           inherits = FALSE)) {
  [22:51:46.284]                           master <- get("master", mode = "list", 
  [22:51:46.284]                             envir = envir, inherits = FALSE)
  [22:51:46.284]                           if (inherits(master, "SOCKnode")) {
  [22:51:46.284]                             sendCondition <<- function(cond) {
  [22:51:46.284]                               data <- list(type = "VALUE", value = cond, 
  [22:51:46.284]                                 success = TRUE)
  [22:51:46.284]                               parallel_sendData(master, data)
  [22:51:46.284]                             }
  [22:51:46.284]                             return(sendCondition)
  [22:51:46.284]                           }
  [22:51:46.284]                         }
  [22:51:46.284]                         frame <- frame + 1L
  [22:51:46.284]                         envir <- sys.frame(frame)
  [22:51:46.284]                       }
  [22:51:46.284]                     }
  [22:51:46.284]                     sendCondition <<- function(cond) NULL
  [22:51:46.284]                   }
  [22:51:46.284]                 })
  [22:51:46.284]                 withCallingHandlers({
  [22:51:46.284]                   NA
  [22:51:46.284]                 }, immediateCondition = function(cond) {
  [22:51:46.284]                   sendCondition <- ...future.sendCondition()
  [22:51:46.284]                   sendCondition(cond)
  [22:51:46.284]                   muffleCondition <- function (cond) 
  [22:51:46.284]                   {
  [22:51:46.284]                     inherits <- base::inherits
  [22:51:46.284]                     invokeRestart <- base::invokeRestart
  [22:51:46.284]                     muffled <- FALSE
  [22:51:46.284]                     if (inherits(cond, "message")) {
  [22:51:46.284]                       invokeRestart("muffleMessage")
  [22:51:46.284]                       muffled <- TRUE
  [22:51:46.284]                     }
  [22:51:46.284]                     else if (inherits(cond, "warning")) {
  [22:51:46.284]                       invokeRestart("muffleWarning")
  [22:51:46.284]                       muffled <- TRUE
  [22:51:46.284]                     }
  [22:51:46.284]                     else if (inherits(cond, "condition")) {
  [22:51:46.284]                       computeRestarts <- base::computeRestarts
  [22:51:46.284]                       grepl <- base::grepl
  [22:51:46.284]                       is.null <- base::is.null
  [22:51:46.284]                       restarts <- computeRestarts(cond)
  [22:51:46.284]                       for (restart in restarts) {
  [22:51:46.284]                         name <- restart$name
  [22:51:46.284]                         if (is.null(name)) 
  [22:51:46.284]                           next
  [22:51:46.284]                         if (!grepl("^muffle", name)) 
  [22:51:46.284]                           next
  [22:51:46.284]                         invokeRestart(restart)
  [22:51:46.284]                         muffled <- TRUE
  [22:51:46.284]                         break
  [22:51:46.284]                       }
  [22:51:46.284]                     }
  [22:51:46.284]                     invisible(muffled)
  [22:51:46.284]                   }
  [22:51:46.284]                   muffleCondition(cond)
  [22:51:46.284]                 })
  [22:51:46.284]             }))
  [22:51:46.284]             future::FutureResult(value = ...future.value$value, 
  [22:51:46.284]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [22:51:46.284]                   ...future.rng), started = ...future.startTime, 
  [22:51:46.284]                 version = "1.8")
  [22:51:46.284]         }, condition = base::local({
  [22:51:46.284]             c <- base::c
  [22:51:46.284]             inherits <- base::inherits
  [22:51:46.284]             invokeRestart <- base::invokeRestart
  [22:51:46.284]             length <- base::length
  [22:51:46.284]             list <- base::list
  [22:51:46.284]             seq.int <- base::seq.int
  [22:51:46.284]             signalCondition <- base::signalCondition
  [22:51:46.284]             sys.calls <- base::sys.calls
  [22:51:46.284]             Sys.time <- base::Sys.time
  [22:51:46.284]             `[[` <- base::`[[`
  [22:51:46.284]             `+` <- base::`+`
  [22:51:46.284]             `<<-` <- base::`<<-`
  [22:51:46.284]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:51:46.284]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:51:46.284]                   3L)]
  [22:51:46.284]             }
  [22:51:46.284]             function(cond) {
  [22:51:46.284]                 if (inherits(cond, "error")) {
  [22:51:46.284]                   sessionInformation <- function() {
  [22:51:46.284]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [22:51:46.284]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [22:51:46.284]                       search = base::search(), system = base::Sys.info())
  [22:51:46.284]                   }
  [22:51:46.284]                   ...future.conditions[[length(...future.conditions) + 
  [22:51:46.284]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:51:46.284]                     cond$call), session = sessionInformation(), 
  [22:51:46.284]                     timestamp = Sys.time(), signaled = 0L)
  [22:51:46.284]                   signalCondition(cond)
  [22:51:46.284]                 }
  [22:51:46.284]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:51:46.284]                 ))) {
  [22:51:46.284]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:51:46.284]                   ...future.conditions[[length(...future.conditions) + 
  [22:51:46.284]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [22:51:46.284]                   if (!signal) {
  [22:51:46.284]                     muffleCondition <- function (cond) 
  [22:51:46.284]                     {
  [22:51:46.284]                       inherits <- base::inherits
  [22:51:46.284]                       invokeRestart <- base::invokeRestart
  [22:51:46.284]                       muffled <- FALSE
  [22:51:46.284]                       if (inherits(cond, "message")) {
  [22:51:46.284]                         invokeRestart("muffleMessage")
  [22:51:46.284]                         muffled <- TRUE
  [22:51:46.284]                       }
  [22:51:46.284]                       else if (inherits(cond, "warning")) {
  [22:51:46.284]                         invokeRestart("muffleWarning")
  [22:51:46.284]                         muffled <- TRUE
  [22:51:46.284]                       }
  [22:51:46.284]                       else if (inherits(cond, "condition")) {
  [22:51:46.284]                         computeRestarts <- base::computeRestarts
  [22:51:46.284]                         grepl <- base::grepl
  [22:51:46.284]                         is.null <- base::is.null
  [22:51:46.284]                         restarts <- computeRestarts(cond)
  [22:51:46.284]                         for (restart in restarts) {
  [22:51:46.284]                           name <- restart$name
  [22:51:46.284]                           if (is.null(name)) 
  [22:51:46.284]                             next
  [22:51:46.284]                           if (!grepl("^muffle", name)) 
  [22:51:46.284]                             next
  [22:51:46.284]                           invokeRestart(restart)
  [22:51:46.284]                           muffled <- TRUE
  [22:51:46.284]                           break
  [22:51:46.284]                         }
  [22:51:46.284]                       }
  [22:51:46.284]                       invisible(muffled)
  [22:51:46.284]                     }
  [22:51:46.284]                     muffleCondition(cond)
  [22:51:46.284]                   }
  [22:51:46.284]                 }
  [22:51:46.284]             }
  [22:51:46.284]         }))
  [22:51:46.284]     }, error = function(ex) {
  [22:51:46.284]         base::structure(base::list(value = NULL, visible = NULL, 
  [22:51:46.284]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [22:51:46.284]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [22:51:46.284]     }, finally = {
  [22:51:46.284]         {
  [22:51:46.284]             {
  [22:51:46.284]                 base::options(mc.cores = ...future.mc.cores.old)
  [22:51:46.284]             }
  [22:51:46.284]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:51:46.284]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:51:46.284]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:51:46.284]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:51:46.284]                 ...) 
  [22:51:46.284]             {
  [22:51:46.284]                 if (substitute) 
  [22:51:46.284]                   expr <- substitute(expr)
  [22:51:46.284]                 if (is.function(workers)) 
  [22:51:46.284]                   workers <- workers()
  [22:51:46.284]                 workers <- as.integer(workers)
  [22:51:46.284]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:51:46.284]                   workers >= 1)
  [22:51:46.284]                 if (workers == 1L) {
  [22:51:46.284]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:51:46.284]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:51:46.284]                     local = TRUE, label = label, ...))
  [22:51:46.284]                 }
  [22:51:46.284]                 workers <- ClusterRegistry("start", workers = workers)
  [22:51:46.284]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:51:46.284]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:51:46.284]                   globals = globals, persistent = persistent, 
  [22:51:46.284]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:51:46.284]                   label = label, ...)
  [22:51:46.284]                 if (!future$lazy) 
  [22:51:46.284]                   future <- run(future)
  [22:51:46.284]                 invisible(future)
  [22:51:46.284]             }), .cleanup = FALSE, .init = FALSE)
  [22:51:46.284]         }
  [22:51:46.284]         base::options(...future.oldOptions)
  [22:51:46.284]     })
  [22:51:46.284]     Sys.time
  [22:51:46.284]     if (base::is.na(TRUE)) {
  [22:51:46.284]     }
  [22:51:46.284]     else {
  [22:51:46.284]         base::sink(type = "output", split = FALSE)
  [22:51:46.284]         if (TRUE) {
  [22:51:46.284]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [22:51:46.284]         }
  [22:51:46.284]         else {
  [22:51:46.284]             ...future.result["stdout"] <- base::list(NULL)
  [22:51:46.284]         }
  [22:51:46.284]         base::close(...future.stdout)
  [22:51:46.284]         ...future.stdout <- NULL
  [22:51:46.284]     }
  [22:51:46.284]     ...future.result$conditions <- ...future.conditions
  [22:51:46.284]     ...future.result
  [22:51:46.284] }
  [22:51:46.293] MultisessionFuture started
  [22:51:46.293] result() for ClusterFuture ...
  [22:51:46.295] receiveMessageFromWorker() for ClusterFuture ...
  [22:51:46.295] - Validating connection of MultisessionFuture
  [22:51:46.482] - received message: FutureResult
  [22:51:46.483] - Received FutureResult
  [22:51:46.483] - Erased future from FutureRegistry
  [22:51:46.484] result() for ClusterFuture ...
  [22:51:46.484] - result already collected: FutureResult
  [22:51:46.484] result() for ClusterFuture ... done
  [22:51:46.485] receiveMessageFromWorker() for ClusterFuture ... done
  [22:51:46.485] result() for ClusterFuture ... done
  [22:51:46.485] result() for ClusterFuture ...
  [22:51:46.486] - result already collected: FutureResult
  [22:51:46.486] result() for ClusterFuture ... done
  [22:51:46.486] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [22:51:46.488] plan(): nbrOfWorkers() = 2
  [22:51:46.488] doFuture() ...
  [22:51:46.491] - dummy globals (as locals): [1] 'i'
  [22:51:46.492] - R expression:
  [22:51:46.493] {
  [22:51:46.493]     doFuture::registerDoFuture()
  [22:51:46.493]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [22:51:46.493]         ...future.x_jj <- ...future.x_ii[[jj]]
  [22:51:46.493]         i <- NULL
  [22:51:46.493]         ...future.env <- environment()
  [22:51:46.493]         local({
  [22:51:46.493]             for (name in names(...future.x_jj)) {
  [22:51:46.493]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [22:51:46.493]                   inherits = FALSE)
  [22:51:46.493]             }
  [22:51:46.493]         })
  [22:51:46.493]         tryCatch({
  [22:51:46.493]             if (i%%2 == 0) 
  [22:51:46.493]                 stop(sprintf("Index error ('stop'), because i = %d", 
  [22:51:46.493]                   i))
  [22:51:46.493]             dnorm(i, mean = mu, sd = sigma)
  [22:51:46.493]         }, error = identity)
  [22:51:46.493]     })
  [22:51:46.493] }
  [22:51:46.493] - identifying globals and packages ...
  [22:51:46.494] getGlobalsAndPackages() ...
  [22:51:46.494] Searching for globals...
  [22:51:46.533] - globals found: [22] '{', '::', 'lapply', 'seq_along', '...future.x_ii', '<-', '[[', 'environment', 'local', 'for', 'names', 'assign', 'tryCatch', 'if', '==', '%%', 'stop', 'sprintf', 'dnorm', 'mu', 'sigma', 'identity'
  [22:51:46.547] Searching for globals ... DONE
  [22:51:46.547] Resolving globals: FALSE
  [22:51:46.550] The total size of the 3 globals is 112 bytes (112 bytes)
  [22:51:46.550] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [22:51:46.551] - packages: [1] 'stats'
  [22:51:46.551] getGlobalsAndPackages() ... DONE
  [22:51:46.551] List of 3
  [22:51:46.551]  $ ...future.x_ii: NULL
  [22:51:46.551]  $ mu            : num 1
  [22:51:46.551]  $ sigma         : num 2
  [22:51:46.551]  - attr(*, "where")=List of 3
  [22:51:46.551]   ..$ ...future.x_ii:<environment: 0x2e55ff0> 
  [22:51:46.551]   ..$ mu            :<environment: R_GlobalEnv> 
  [22:51:46.551]   ..$ sigma         :<environment: R_GlobalEnv> 
  [22:51:46.551]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:51:46.551]  - attr(*, "resolved")= logi FALSE
  [22:51:46.551]  - attr(*, "total_size")= num 112
  [22:51:46.579]   - R expression:
  [22:51:46.579] {
  [22:51:46.579]     doFuture::registerDoFuture()
  [22:51:46.579]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [22:51:46.579]         ...future.x_jj <- ...future.x_ii[[jj]]
  [22:51:46.579]         i <- NULL
  [22:51:46.579]         ...future.env <- environment()
  [22:51:46.579]         local({
  [22:51:46.579]             for (name in names(...future.x_jj)) {
  [22:51:46.579]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [22:51:46.579]                   inherits = FALSE)
  [22:51:46.579]             }
  [22:51:46.579]         })
  [22:51:46.579]         tryCatch({
  [22:51:46.579]             if (i%%2 == 0) 
  [22:51:46.579]                 stop(sprintf("Index error ('stop'), because i = %d", 
  [22:51:46.579]                   i))
  [22:51:46.579]             dnorm(i, mean = mu, sd = sigma)
  [22:51:46.579]         }, error = identity)
  [22:51:46.579]     })
  [22:51:46.579] }
  [22:51:46.580]   - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [22:51:46.581] List of 3
  [22:51:46.581]  $ ...future.x_ii: NULL
  [22:51:46.581]  $ mu            : num 1
  [22:51:46.581]  $ sigma         : num 2
  [22:51:46.581]  - attr(*, "where")=List of 3
  [22:51:46.581]   ..$ ...future.x_ii:<environment: 0x2e55ff0> 
  [22:51:46.581]   ..$ mu            :<environment: R_GlobalEnv> 
  [22:51:46.581]   ..$ sigma         :<environment: R_GlobalEnv> 
  [22:51:46.581]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [22:51:46.581]  - attr(*, "resolved")= logi FALSE
  [22:51:46.581]  - attr(*, "total_size")= num 112
  [22:51:46.592]   - packages: [2] 'doFuture', 'stats'
  [22:51:46.592] - identifying globals and packages ... DONE
  [22:51:46.594] Number of chunks: 2
  [22:51:46.594] Number of futures (= number of chunks): 2
  [22:51:46.619] Launching 2 futures (chunks) ...
  [22:51:46.619] Chunk #1 of 2 ...
  [22:51:46.620]  - Finding globals in 'args_list' chunk #1 ...
  [22:51:46.620] getGlobalsAndPackages() ...
  [22:51:46.621] Searching for globals...
  [22:51:46.622] 
  [22:51:46.622] Searching for globals ... DONE
  [22:51:46.622] - globals: [0] <none>
  [22:51:46.623] getGlobalsAndPackages() ... DONE
  [22:51:46.623] 
  [22:51:46.623] 
  [22:51:46.624]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [22:51:46.625] getGlobalsAndPackages() ...
  [22:51:46.625] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [22:51:46.626] Resolving globals: FALSE
  [22:51:46.627] The total size of the 3 globals is 392 bytes (392 bytes)
  [22:51:46.628] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [22:51:46.628] 
  [22:51:46.628] getGlobalsAndPackages() ... DONE
  [22:51:46.633] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [22:51:46.634] Packages needed by future strategies (n = 0): <none>
  [22:51:46.656] {
  [22:51:46.656]     {
  [22:51:46.656]         ...future.startTime <- base::Sys.time()
  [22:51:46.656]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [22:51:46.656]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:51:46.656]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:51:46.656]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:51:46.656]             future.resolve.recursive = NULL, width = 80L)
  [22:51:46.656]         {
  [22:51:46.656]             {
  [22:51:46.656]                 {
  [22:51:46.656]                   {
  [22:51:46.656]                     base::local({
  [22:51:46.656]                       has_future <- base::requireNamespace("future", 
  [22:51:46.656]                         quietly = TRUE)
  [22:51:46.656]                       version <- if (has_future) 
  [22:51:46.656]                         utils::packageVersion("future")
  [22:51:46.656]                       else NULL
  [22:51:46.656]                       if (!has_future || version < "1.8.0") {
  [22:51:46.656]                         info <- base::c(r_version = base::gsub("R version ", 
  [22:51:46.656]                           "", base::R.version$version.string), 
  [22:51:46.656]                           platform = base::sprintf("%s (%s-bit)", 
  [22:51:46.656]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [22:51:46.656]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [22:51:46.656]                             "release", "version")], collapse = " "), 
  [22:51:46.656]                           hostname = base::Sys.info()[["nodename"]])
  [22:51:46.656]                         info <- base::sprintf("%s: %s", base::names(info), 
  [22:51:46.656]                           info)
  [22:51:46.656]                         info <- base::paste(info, collapse = "; ")
  [22:51:46.656]                         if (!has_future) {
  [22:51:46.656]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [22:51:46.656]                             info)
  [22:51:46.656]                         }
  [22:51:46.656]                         else {
  [22:51:46.656]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:51:46.656]                             info, version)
  [22:51:46.656]                         }
  [22:51:46.656]                         base::stop(msg)
  [22:51:46.656]                       }
  [22:51:46.656]                     })
  [22:51:46.656]                   }
  [22:51:46.656]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [22:51:46.656]                   base::options(mc.cores = 1L)
  [22:51:46.656]                 }
  [22:51:46.656]                 base::local({
  [22:51:46.656]                   for (pkg in c("doFuture", "stats")) {
  [22:51:46.656]                     base::loadNamespace(pkg)
  [22:51:46.656]                     base::library(pkg, character.only = TRUE)
  [22:51:46.656]                   }
  [22:51:46.656]                 })
  [22:51:46.656]             }
  [22:51:46.656]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:51:46.656]         }
  [22:51:46.656]     }
  [22:51:46.656]     if (base::is.na(TRUE)) {
  [22:51:46.656]     }
  [22:51:46.656]     else {
  [22:51:46.656]         if (TRUE) {
  [22:51:46.656]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [22:51:46.656]                 open = "w")
  [22:51:46.656]         }
  [22:51:46.656]         else {
  [22:51:46.656]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [22:51:46.656]                 windows = "NUL", "/dev/null"), open = "w")
  [22:51:46.656]         }
  [22:51:46.656]         base::sink(...future.stdout, type = "output", split = FALSE)
  [22:51:46.656]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [22:51:46.656]             base::sink(type = "output", split = FALSE)
  [22:51:46.656]             base::close(...future.stdout)
  [22:51:46.656]         }, add = TRUE)
  [22:51:46.656]     }
  [22:51:46.656]     ...future.frame <- base::sys.nframe()
  [22:51:46.656]     ...future.conditions <- base::list()
  [22:51:46.656]     ...future.rng <- base::globalenv()$.Random.seed
  [22:51:46.656]     ...future.result <- base::tryCatch({
  [22:51:46.656]         base::withCallingHandlers({
  [22:51:46.656]             ...future.value <- base::withVisible(base::local({
  [22:51:46.656]                 ...future.sendCondition <- local({
  [22:51:46.656]                   sendCondition <- NULL
  [22:51:46.656]                   function(frame = 1L) {
  [22:51:46.656]                     if (is.function(sendCondition)) 
  [22:51:46.656]                       return(sendCondition)
  [22:51:46.656]                     ns <- getNamespace("parallel")
  [22:51:46.656]                     if (exists("sendData", mode = "function", 
  [22:51:46.656]                       envir = ns)) {
  [22:51:46.656]                       parallel_sendData <- get("sendData", mode = "function", 
  [22:51:46.656]                         envir = ns)
  [22:51:46.656]                       envir <- sys.frame(frame)
  [22:51:46.656]                       master <- NULL
  [22:51:46.656]                       while (!identical(envir, .GlobalEnv) && 
  [22:51:46.656]                         !identical(envir, emptyenv())) {
  [22:51:46.656]                         if (exists("master", mode = "list", envir = envir, 
  [22:51:46.656]                           inherits = FALSE)) {
  [22:51:46.656]                           master <- get("master", mode = "list", 
  [22:51:46.656]                             envir = envir, inherits = FALSE)
  [22:51:46.656]                           if (inherits(master, "SOCKnode")) {
  [22:51:46.656]                             sendCondition <<- function(cond) {
  [22:51:46.656]                               data <- list(type = "VALUE", value = cond, 
  [22:51:46.656]                                 success = TRUE)
  [22:51:46.656]                               parallel_sendData(master, data)
  [22:51:46.656]                             }
  [22:51:46.656]                             return(sendCondition)
  [22:51:46.656]                           }
  [22:51:46.656]                         }
  [22:51:46.656]                         frame <- frame + 1L
  [22:51:46.656]                         envir <- sys.frame(frame)
  [22:51:46.656]                       }
  [22:51:46.656]                     }
  [22:51:46.656]                     sendCondition <<- function(cond) NULL
  [22:51:46.656]                   }
  [22:51:46.656]                 })
  [22:51:46.656]                 withCallingHandlers({
  [22:51:46.656]                   {
  [22:51:46.656]                     doFuture::registerDoFuture()
  [22:51:46.656]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [22:51:46.656]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [22:51:46.656]                       i <- NULL
  [22:51:46.656]                       ...future.env <- environment()
  [22:51:46.656]                       local({
  [22:51:46.656]                         for (name in names(...future.x_jj)) {
  [22:51:46.656]                           assign(name, ...future.x_jj[[name]], 
  [22:51:46.656]                             envir = ...future.env, inherits = FALSE)
  [22:51:46.656]                         }
  [22:51:46.656]                       })
  [22:51:46.656]                       tryCatch({
  [22:51:46.656]                         if (i%%2 == 0) 
  [22:51:46.656]                           stop(sprintf("Index error ('stop'), because i = %d", 
  [22:51:46.656]                             i))
  [22:51:46.656]                         dnorm(i, mean = mu, sd = sigma)
  [22:51:46.656]                       }, error = identity)
  [22:51:46.656]                     })
  [22:51:46.656]                   }
  [22:51:46.656]                 }, immediateCondition = function(cond) {
  [22:51:46.656]                   sendCondition <- ...future.sendCondition()
  [22:51:46.656]                   sendCondition(cond)
  [22:51:46.656]                   muffleCondition <- function (cond) 
  [22:51:46.656]                   {
  [22:51:46.656]                     inherits <- base::inherits
  [22:51:46.656]                     invokeRestart <- base::invokeRestart
  [22:51:46.656]                     muffled <- FALSE
  [22:51:46.656]                     if (inherits(cond, "message")) {
  [22:51:46.656]                       invokeRestart("muffleMessage")
  [22:51:46.656]                       muffled <- TRUE
  [22:51:46.656]                     }
  [22:51:46.656]                     else if (inherits(cond, "warning")) {
  [22:51:46.656]                       invokeRestart("muffleWarning")
  [22:51:46.656]                       muffled <- TRUE
  [22:51:46.656]                     }
  [22:51:46.656]                     else if (inherits(cond, "condition")) {
  [22:51:46.656]                       computeRestarts <- base::computeRestarts
  [22:51:46.656]                       grepl <- base::grepl
  [22:51:46.656]                       is.null <- base::is.null
  [22:51:46.656]                       restarts <- computeRestarts(cond)
  [22:51:46.656]                       for (restart in restarts) {
  [22:51:46.656]                         name <- restart$name
  [22:51:46.656]                         if (is.null(name)) 
  [22:51:46.656]                           next
  [22:51:46.656]                         if (!grepl("^muffle", name)) 
  [22:51:46.656]                           next
  [22:51:46.656]                         invokeRestart(restart)
  [22:51:46.656]                         muffled <- TRUE
  [22:51:46.656]                         break
  [22:51:46.656]                       }
  [22:51:46.656]                     }
  [22:51:46.656]                     invisible(muffled)
  [22:51:46.656]                   }
  [22:51:46.656]                   muffleCondition(cond)
  [22:51:46.656]                 })
  [22:51:46.656]             }))
  [22:51:46.656]             future::FutureResult(value = ...future.value$value, 
  [22:51:46.656]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [22:51:46.656]                   ...future.rng), started = ...future.startTime, 
  [22:51:46.656]                 version = "1.8")
  [22:51:46.656]         }, condition = base::local({
  [22:51:46.656]             c <- base::c
  [22:51:46.656]             inherits <- base::inherits
  [22:51:46.656]             invokeRestart <- base::invokeRestart
  [22:51:46.656]             length <- base::length
  [22:51:46.656]             list <- base::list
  [22:51:46.656]             seq.int <- base::seq.int
  [22:51:46.656]             signalCondition <- base::signalCondition
  [22:51:46.656]             sys.calls <- base::sys.calls
  [22:51:46.656]             Sys.time <- base::Sys.time
  [22:51:46.656]             `[[` <- base::`[[`
  [22:51:46.656]             `+` <- base::`+`
  [22:51:46.656]             `<<-` <- base::`<<-`
  [22:51:46.656]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:51:46.656]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:51:46.656]                   3L)]
  [22:51:46.656]             }
  [22:51:46.656]             function(cond) {
  [22:51:46.656]                 if (inherits(cond, "error")) {
  [22:51:46.656]                   sessionInformation <- function() {
  [22:51:46.656]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [22:51:46.656]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [22:51:46.656]                       search = base::search(), system = base::Sys.info())
  [22:51:46.656]                   }
  [22:51:46.656]                   ...future.conditions[[length(...future.conditions) + 
  [22:51:46.656]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:51:46.656]                     cond$call), session = sessionInformation(), 
  [22:51:46.656]                     timestamp = Sys.time(), signaled = 0L)
  [22:51:46.656]                   signalCondition(cond)
  [22:51:46.656]                 }
  [22:51:46.656]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:51:46.656]                 ))) {
  [22:51:46.656]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:51:46.656]                   ...future.conditions[[length(...future.conditions) + 
  [22:51:46.656]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [22:51:46.656]                   if (!signal) {
  [22:51:46.656]                     muffleCondition <- function (cond) 
  [22:51:46.656]                     {
  [22:51:46.656]                       inherits <- base::inherits
  [22:51:46.656]                       invokeRestart <- base::invokeRestart
  [22:51:46.656]                       muffled <- FALSE
  [22:51:46.656]                       if (inherits(cond, "message")) {
  [22:51:46.656]                         invokeRestart("muffleMessage")
  [22:51:46.656]                         muffled <- TRUE
  [22:51:46.656]                       }
  [22:51:46.656]                       else if (inherits(cond, "warning")) {
  [22:51:46.656]                         invokeRestart("muffleWarning")
  [22:51:46.656]                         muffled <- TRUE
  [22:51:46.656]                       }
  [22:51:46.656]                       else if (inherits(cond, "condition")) {
  [22:51:46.656]                         computeRestarts <- base::computeRestarts
  [22:51:46.656]                         grepl <- base::grepl
  [22:51:46.656]                         is.null <- base::is.null
  [22:51:46.656]                         restarts <- computeRestarts(cond)
  [22:51:46.656]                         for (restart in restarts) {
  [22:51:46.656]                           name <- restart$name
  [22:51:46.656]                           if (is.null(name)) 
  [22:51:46.656]                             next
  [22:51:46.656]                           if (!grepl("^muffle", name)) 
  [22:51:46.656]                             next
  [22:51:46.656]                           invokeRestart(restart)
  [22:51:46.656]                           muffled <- TRUE
  [22:51:46.656]                           break
  [22:51:46.656]                         }
  [22:51:46.656]                       }
  [22:51:46.656]                       invisible(muffled)
  [22:51:46.656]                     }
  [22:51:46.656]                     muffleCondition(cond)
  [22:51:46.656]                   }
  [22:51:46.656]                 }
  [22:51:46.656]             }
  [22:51:46.656]         }))
  [22:51:46.656]     }, error = function(ex) {
  [22:51:46.656]         base::structure(base::list(value = NULL, visible = NULL, 
  [22:51:46.656]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [22:51:46.656]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [22:51:46.656]     }, finally = {
  [22:51:46.656]         {
  [22:51:46.656]             {
  [22:51:46.656]                 base::options(mc.cores = ...future.mc.cores.old)
  [22:51:46.656]             }
  [22:51:46.656]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:51:46.656]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:51:46.656]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:51:46.656]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:51:46.656]                 ...) 
  [22:51:46.656]             {
  [22:51:46.656]                 if (substitute) 
  [22:51:46.656]                   expr <- substitute(expr)
  [22:51:46.656]                 if (is.function(workers)) 
  [22:51:46.656]                   workers <- workers()
  [22:51:46.656]                 workers <- as.integer(workers)
  [22:51:46.656]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:51:46.656]                   workers >= 1)
  [22:51:46.656]                 if (workers == 1L) {
  [22:51:46.656]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:51:46.656]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:51:46.656]                     local = TRUE, label = label, ...))
  [22:51:46.656]                 }
  [22:51:46.656]                 workers <- ClusterRegistry("start", workers = workers)
  [22:51:46.656]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:51:46.656]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:51:46.656]                   globals = globals, persistent = persistent, 
  [22:51:46.656]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:51:46.656]                   label = label, ...)
  [22:51:46.656]                 if (!future$lazy) 
  [22:51:46.656]                   future <- run(future)
  [22:51:46.656]                 invisible(future)
  [22:51:46.656]             }), .cleanup = FALSE, .init = FALSE)
  [22:51:46.656]         }
  [22:51:46.656]         base::options(...future.oldOptions)
  [22:51:46.656]     })
  [22:51:46.656]     Sys.time
  [22:51:46.656]     if (base::is.na(TRUE)) {
  [22:51:46.656]     }
  [22:51:46.656]     else {
  [22:51:46.656]         base::sink(type = "output", split = FALSE)
  [22:51:46.656]         if (TRUE) {
  [22:51:46.656]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [22:51:46.656]         }
  [22:51:46.656]         else {
  [22:51:46.656]             ...future.result["stdout"] <- base::list(NULL)
  [22:51:46.656]         }
  [22:51:46.656]         base::close(...future.stdout)
  [22:51:46.656]         ...future.stdout <- NULL
  [22:51:46.656]     }
  [22:51:46.656]     ...future.result$conditions <- ...future.conditions
  [22:51:46.656]     ...future.result
  [22:51:46.656] }
  [22:51:46.679] Exporting 3 global objects (392 bytes) to cluster node #1 ...
  [22:51:46.679] Exporting '...future.x_ii' (280 bytes) to cluster node #1 ...
  [22:51:46.681] Exporting '...future.x_ii' (280 bytes) to cluster node #1 ... DONE
  [22:51:46.681] Exporting 'mu' (56 bytes) to cluster node #1 ...
  [22:51:46.682] Exporting 'mu' (56 bytes) to cluster node #1 ... DONE
  [22:51:46.683] Exporting 'sigma' (56 bytes) to cluster node #1 ...
  [22:51:46.684] Exporting 'sigma' (56 bytes) to cluster node #1 ... DONE
  [22:51:46.684] Exporting 3 global objects (392 bytes) to cluster node #1 ... DONE
  [22:51:46.693] MultisessionFuture started
  [22:51:46.694] Chunk #1 of 2 ... DONE
  [22:51:46.694] Chunk #2 of 2 ...
  [22:51:46.694]  - Finding globals in 'args_list' chunk #2 ...
  [22:51:46.695] getGlobalsAndPackages() ...
  [22:51:46.695] Searching for globals...
  [22:51:46.696] 
  [22:51:46.697] Searching for globals ... DONE
  [22:51:46.697] - globals: [0] <none>
  [22:51:46.697] getGlobalsAndPackages() ... DONE
  [22:51:46.698] 
  [22:51:46.698] 
  [22:51:46.699]  - Finding globals in 'args_list' for chunk #2 ... DONE
  [22:51:46.700] getGlobalsAndPackages() ...
  [22:51:46.700] - globals passed as-is: [3] '...future.x_ii', 'mu', 'sigma'
  [22:51:46.701] Resolving globals: FALSE
  [22:51:46.702] The total size of the 3 globals is 392 bytes (392 bytes)
  [22:51:46.703] - globals: [3] '...future.x_ii', 'mu', 'sigma'
  [22:51:46.703] 
  [22:51:46.703] getGlobalsAndPackages() ... DONE
  [22:51:46.708] Packages needed by the future expression (n = 2): 'doFuture', 'stats'
  [22:51:46.709] Packages needed by future strategies (n = 0): <none>
  [22:51:46.715] {
  [22:51:46.715]     {
  [22:51:46.715]         ...future.startTime <- base::Sys.time()
  [22:51:46.715]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [22:51:46.715]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [22:51:46.715]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [22:51:46.715]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [22:51:46.715]             future.resolve.recursive = NULL, width = 80L)
  [22:51:46.715]         {
  [22:51:46.715]             {
  [22:51:46.715]                 {
  [22:51:46.715]                   {
  [22:51:46.715]                     base::local({
  [22:51:46.715]                       has_future <- base::requireNamespace("future", 
  [22:51:46.715]                         quietly = TRUE)
  [22:51:46.715]                       version <- if (has_future) 
  [22:51:46.715]                         utils::packageVersion("future")
  [22:51:46.715]                       else NULL
  [22:51:46.715]                       if (!has_future || version < "1.8.0") {
  [22:51:46.715]                         info <- base::c(r_version = base::gsub("R version ", 
  [22:51:46.715]                           "", base::R.version$version.string), 
  [22:51:46.715]                           platform = base::sprintf("%s (%s-bit)", 
  [22:51:46.715]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [22:51:46.715]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [22:51:46.715]                             "release", "version")], collapse = " "), 
  [22:51:46.715]                           hostname = base::Sys.info()[["nodename"]])
  [22:51:46.715]                         info <- base::sprintf("%s: %s", base::names(info), 
  [22:51:46.715]                           info)
  [22:51:46.715]                         info <- base::paste(info, collapse = "; ")
  [22:51:46.715]                         if (!has_future) {
  [22:51:46.715]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [22:51:46.715]                             info)
  [22:51:46.715]                         }
  [22:51:46.715]                         else {
  [22:51:46.715]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [22:51:46.715]                             info, version)
  [22:51:46.715]                         }
  [22:51:46.715]                         base::stop(msg)
  [22:51:46.715]                       }
  [22:51:46.715]                     })
  [22:51:46.715]                   }
  [22:51:46.715]                   ...future.mc.cores.old <- base::getOption("mc.cores")
  [22:51:46.715]                   base::options(mc.cores = 1L)
  [22:51:46.715]                 }
  [22:51:46.715]                 base::local({
  [22:51:46.715]                   for (pkg in c("doFuture", "stats")) {
  [22:51:46.715]                     base::loadNamespace(pkg)
  [22:51:46.715]                     base::library(pkg, character.only = TRUE)
  [22:51:46.715]                   }
  [22:51:46.715]                 })
  [22:51:46.715]             }
  [22:51:46.715]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [22:51:46.715]         }
  [22:51:46.715]     }
  [22:51:46.715]     if (base::is.na(TRUE)) {
  [22:51:46.715]     }
  [22:51:46.715]     else {
  [22:51:46.715]         if (TRUE) {
  [22:51:46.715]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [22:51:46.715]                 open = "w")
  [22:51:46.715]         }
  [22:51:46.715]         else {
  [22:51:46.715]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [22:51:46.715]                 windows = "NUL", "/dev/null"), open = "w")
  [22:51:46.715]         }
  [22:51:46.715]         base::sink(...future.stdout, type = "output", split = FALSE)
  [22:51:46.715]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [22:51:46.715]             base::sink(type = "output", split = FALSE)
  [22:51:46.715]             base::close(...future.stdout)
  [22:51:46.715]         }, add = TRUE)
  [22:51:46.715]     }
  [22:51:46.715]     ...future.frame <- base::sys.nframe()
  [22:51:46.715]     ...future.conditions <- base::list()
  [22:51:46.715]     ...future.rng <- base::globalenv()$.Random.seed
  [22:51:46.715]     ...future.result <- base::tryCatch({
  [22:51:46.715]         base::withCallingHandlers({
  [22:51:46.715]             ...future.value <- base::withVisible(base::local({
  [22:51:46.715]                 ...future.sendCondition <- local({
  [22:51:46.715]                   sendCondition <- NULL
  [22:51:46.715]                   function(frame = 1L) {
  [22:51:46.715]                     if (is.function(sendCondition)) 
  [22:51:46.715]                       return(sendCondition)
  [22:51:46.715]                     ns <- getNamespace("parallel")
  [22:51:46.715]                     if (exists("sendData", mode = "function", 
  [22:51:46.715]                       envir = ns)) {
  [22:51:46.715]                       parallel_sendData <- get("sendData", mode = "function", 
  [22:51:46.715]                         envir = ns)
  [22:51:46.715]                       envir <- sys.frame(frame)
  [22:51:46.715]                       master <- NULL
  [22:51:46.715]                       while (!identical(envir, .GlobalEnv) && 
  [22:51:46.715]                         !identical(envir, emptyenv())) {
  [22:51:46.715]                         if (exists("master", mode = "list", envir = envir, 
  [22:51:46.715]                           inherits = FALSE)) {
  [22:51:46.715]                           master <- get("master", mode = "list", 
  [22:51:46.715]                             envir = envir, inherits = FALSE)
  [22:51:46.715]                           if (inherits(master, "SOCKnode")) {
  [22:51:46.715]                             sendCondition <<- function(cond) {
  [22:51:46.715]                               data <- list(type = "VALUE", value = cond, 
  [22:51:46.715]                                 success = TRUE)
  [22:51:46.715]                               parallel_sendData(master, data)
  [22:51:46.715]                             }
  [22:51:46.715]                             return(sendCondition)
  [22:51:46.715]                           }
  [22:51:46.715]                         }
  [22:51:46.715]                         frame <- frame + 1L
  [22:51:46.715]                         envir <- sys.frame(frame)
  [22:51:46.715]                       }
  [22:51:46.715]                     }
  [22:51:46.715]                     sendCondition <<- function(cond) NULL
  [22:51:46.715]                   }
  [22:51:46.715]                 })
  [22:51:46.715]                 withCallingHandlers({
  [22:51:46.715]                   {
  [22:51:46.715]                     doFuture::registerDoFuture()
  [22:51:46.715]                     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [22:51:46.715]                       ...future.x_jj <- ...future.x_ii[[jj]]
  [22:51:46.715]                       i <- NULL
  [22:51:46.715]                       ...future.env <- environment()
  [22:51:46.715]                       local({
  [22:51:46.715]                         for (name in names(...future.x_jj)) {
  [22:51:46.715]                           assign(name, ...future.x_jj[[name]], 
  [22:51:46.715]                             envir = ...future.env, inherits = FALSE)
  [22:51:46.715]                         }
  [22:51:46.715]                       })
  [22:51:46.715]                       tryCatch({
  [22:51:46.715]                         if (i%%2 == 0) 
  [22:51:46.715]                           stop(sprintf("Index error ('stop'), because i = %d", 
  [22:51:46.715]                             i))
  [22:51:46.715]                         dnorm(i, mean = mu, sd = sigma)
  [22:51:46.715]                       }, error = identity)
  [22:51:46.715]                     })
  [22:51:46.715]                   }
  [22:51:46.715]                 }, immediateCondition = function(cond) {
  [22:51:46.715]                   sendCondition <- ...future.sendCondition()
  [22:51:46.715]                   sendCondition(cond)
  [22:51:46.715]                   muffleCondition <- function (cond) 
  [22:51:46.715]                   {
  [22:51:46.715]                     inherits <- base::inherits
  [22:51:46.715]                     invokeRestart <- base::invokeRestart
  [22:51:46.715]                     muffled <- FALSE
  [22:51:46.715]                     if (inherits(cond, "message")) {
  [22:51:46.715]                       invokeRestart("muffleMessage")
  [22:51:46.715]                       muffled <- TRUE
  [22:51:46.715]                     }
  [22:51:46.715]                     else if (inherits(cond, "warning")) {
  [22:51:46.715]                       invokeRestart("muffleWarning")
  [22:51:46.715]                       muffled <- TRUE
  [22:51:46.715]                     }
  [22:51:46.715]                     else if (inherits(cond, "condition")) {
  [22:51:46.715]                       computeRestarts <- base::computeRestarts
  [22:51:46.715]                       grepl <- base::grepl
  [22:51:46.715]                       is.null <- base::is.null
  [22:51:46.715]                       restarts <- computeRestarts(cond)
  [22:51:46.715]                       for (restart in restarts) {
  [22:51:46.715]                         name <- restart$name
  [22:51:46.715]                         if (is.null(name)) 
  [22:51:46.715]                           next
  [22:51:46.715]                         if (!grepl("^muffle", name)) 
  [22:51:46.715]                           next
  [22:51:46.715]                         invokeRestart(restart)
  [22:51:46.715]                         muffled <- TRUE
  [22:51:46.715]                         break
  [22:51:46.715]                       }
  [22:51:46.715]                     }
  [22:51:46.715]                     invisible(muffled)
  [22:51:46.715]                   }
  [22:51:46.715]                   muffleCondition(cond)
  [22:51:46.715]                 })
  [22:51:46.715]             }))
  [22:51:46.715]             future::FutureResult(value = ...future.value$value, 
  [22:51:46.715]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [22:51:46.715]                   ...future.rng), started = ...future.startTime, 
  [22:51:46.715]                 version = "1.8")
  [22:51:46.715]         }, condition = base::local({
  [22:51:46.715]             c <- base::c
  [22:51:46.715]             inherits <- base::inherits
  [22:51:46.715]             invokeRestart <- base::invokeRestart
  [22:51:46.715]             length <- base::length
  [22:51:46.715]             list <- base::list
  [22:51:46.715]             seq.int <- base::seq.int
  [22:51:46.715]             signalCondition <- base::signalCondition
  [22:51:46.715]             sys.calls <- base::sys.calls
  [22:51:46.715]             Sys.time <- base::Sys.time
  [22:51:46.715]             `[[` <- base::`[[`
  [22:51:46.715]             `+` <- base::`+`
  [22:51:46.715]             `<<-` <- base::`<<-`
  [22:51:46.715]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [22:51:46.715]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [22:51:46.715]                   3L)]
  [22:51:46.715]             }
  [22:51:46.715]             function(cond) {
  [22:51:46.715]                 if (inherits(cond, "error")) {
  [22:51:46.715]                   sessionInformation <- function() {
  [22:51:46.715]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [22:51:46.715]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [22:51:46.715]                       search = base::search(), system = base::Sys.info())
  [22:51:46.715]                   }
  [22:51:46.715]                   ...future.conditions[[length(...future.conditions) + 
  [22:51:46.715]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [22:51:46.715]                     cond$call), session = sessionInformation(), 
  [22:51:46.715]                     timestamp = Sys.time(), signaled = 0L)
  [22:51:46.715]                   signalCondition(cond)
  [22:51:46.715]                 }
  [22:51:46.715]                 else if (inherits(cond, c("condition", "immediateCondition"
  [22:51:46.715]                 ))) {
  [22:51:46.715]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [22:51:46.715]                   ...future.conditions[[length(...future.conditions) + 
  [22:51:46.715]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [22:51:46.715]                   if (!signal) {
  [22:51:46.715]                     muffleCondition <- function (cond) 
  [22:51:46.715]                     {
  [22:51:46.715]                       inherits <- base::inherits
  [22:51:46.715]                       invokeRestart <- base::invokeRestart
  [22:51:46.715]                       muffled <- FALSE
  [22:51:46.715]                       if (inherits(cond, "message")) {
  [22:51:46.715]                         invokeRestart("muffleMessage")
  [22:51:46.715]                         muffled <- TRUE
  [22:51:46.715]                       }
  [22:51:46.715]                       else if (inherits(cond, "warning")) {
  [22:51:46.715]                         invokeRestart("muffleWarning")
  [22:51:46.715]                         muffled <- TRUE
  [22:51:46.715]                       }
  [22:51:46.715]                       else if (inherits(cond, "condition")) {
  [22:51:46.715]                         computeRestarts <- base::computeRestarts
  [22:51:46.715]                         grepl <- base::grepl
  [22:51:46.715]                         is.null <- base::is.null
  [22:51:46.715]                         restarts <- computeRestarts(cond)
  [22:51:46.715]                         for (restart in restarts) {
  [22:51:46.715]                           name <- restart$name
  [22:51:46.715]                           if (is.null(name)) 
  [22:51:46.715]                             next
  [22:51:46.715]                           if (!grepl("^muffle", name)) 
  [22:51:46.715]                             next
  [22:51:46.715]                           invokeRestart(restart)
  [22:51:46.715]                           muffled <- TRUE
  [22:51:46.715]                           break
  [22:51:46.715]                         }
  [22:51:46.715]                       }
  [22:51:46.715]                       invisible(muffled)
  [22:51:46.715]                     }
  [22:51:46.715]                     muffleCondition(cond)
  [22:51:46.715]                   }
  [22:51:46.715]                 }
  [22:51:46.715]             }
  [22:51:46.715]         }))
  [22:51:46.715]     }, error = function(ex) {
  [22:51:46.715]         base::structure(base::list(value = NULL, visible = NULL, 
  [22:51:46.715]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [22:51:46.715]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [22:51:46.715]     }, finally = {
  [22:51:46.715]         {
  [22:51:46.715]             {
  [22:51:46.715]                 base::options(mc.cores = ...future.mc.cores.old)
  [22:51:46.715]             }
  [22:51:46.715]             future::plan(list(function (expr, envir = parent.frame(), 
  [22:51:46.715]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [22:51:46.715]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [22:51:46.715]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [22:51:46.715]                 ...) 
  [22:51:46.715]             {
  [22:51:46.715]                 if (substitute) 
  [22:51:46.715]                   expr <- substitute(expr)
  [22:51:46.715]                 if (is.function(workers)) 
  [22:51:46.715]                   workers <- workers()
  [22:51:46.715]                 workers <- as.integer(workers)
  [22:51:46.715]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [22:51:46.715]                   workers >= 1)
  [22:51:46.715]                 if (workers == 1L) {
  [22:51:46.715]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [22:51:46.715]                     lazy = TRUE, seed = seed, globals = globals, 
  [22:51:46.715]                     local = TRUE, label = label, ...))
  [22:51:46.715]                 }
  [22:51:46.715]                 workers <- ClusterRegistry("start", workers = workers)
  [22:51:46.715]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [22:51:46.715]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [22:51:46.715]                   globals = globals, persistent = persistent, 
  [22:51:46.715]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [22:51:46.715]                   label = label, ...)
  [22:51:46.715]                 if (!future$lazy) 
  [22:51:46.715]                   future <- run(future)
  [22:51:46.715]                 invisible(future)
  [22:51:46.715]             }), .cleanup = FALSE, .init = FALSE)
  [22:51:46.715]         }
  [22:51:46.715]         base::options(...future.oldOptions)
  [22:51:46.715]     })
  [22:51:46.715]     Sys.time
  [22:51:46.715]     if (base::is.na(TRUE)) {
  [22:51:46.715]     }
  [22:51:46.715]     else {
  [22:51:46.715]         base::sink(type = "output", split = FALSE)
  [22:51:46.715]         if (TRUE) {
  [22:51:46.715]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [22:51:46.715]         }
  [22:51:46.715]         else {
  [22:51:46.715]             ...future.result["stdout"] <- base::list(NULL)
  [22:51:46.715]         }
  [22:51:46.715]         base::close(...future.stdout)
  [22:51:46.715]         ...future.stdout <- NULL
  [22:51:46.715]     }
  [22:51:46.715]     ...future.result$conditions <- ...future.conditions
  [22:51:46.715]     ...future.result
  [22:51:46.715] }
  [22:51:46.720] Exporting 3 global objects (392 bytes) to cluster node #2 ...
  [22:51:46.721] Exporting '...future.x_ii' (280 bytes) to cluster node #2 ...
  [22:51:46.722] Exporting '...future.x_ii' (280 bytes) to cluster node #2 ... DONE
  [22:51:46.723] Exporting 'mu' (56 bytes) to cluster node #2 ...
  [22:51:46.724] Exporting 'mu' (56 bytes) to cluster node #2 ... DONE
  [22:51:46.724] Exporting 'sigma' (56 bytes) to cluster node #2 ...
  [22:51:46.725] Exporting 'sigma' (56 bytes) to cluster node #2 ... DONE
  [22:51:46.725] Exporting 3 global objects (392 bytes) to cluster node #2 ... DONE
  [22:51:46.727] MultisessionFuture started
  [22:51:46.727] Chunk #2 of 2 ... DONE
  [22:51:46.728] Launching 2 futures (chunks) ... DONE
  [22:51:46.728] - resolving futures
  [22:51:46.728]   - gathering results & relaying conditions (except errors)
  [22:51:46.729] resolve() on list ...
  [22:51:46.729]  recursive: 0
  [22:51:46.729]  length: 2
  [22:51:46.730] 
  [22:51:46.878] receiveMessageFromWorker() for ClusterFuture ...
  [22:51:46.878] - Validating connection of MultisessionFuture
  [22:51:46.879] - received message: FutureResult
  [22:51:46.879] - Received FutureResult
  [22:51:46.879] - Erased future from FutureRegistry
  [22:51:46.880] result() for ClusterFuture ...
  [22:51:46.880] - result already collected: FutureResult
  [22:51:46.880] result() for ClusterFuture ... done
  [22:51:46.881] receiveMessageFromWorker() for ClusterFuture ... done
  [22:51:46.881] Future #1
  [22:51:46.881] result() for ClusterFuture ...
  [22:51:46.882] - result already collected: FutureResult
  [22:51:46.882] result() for ClusterFuture ... done
  [22:51:46.882] result() for ClusterFuture ...
  [22:51:46.883] - result already collected: FutureResult
  [22:51:46.883] result() for ClusterFuture ... done
  [22:51:46.883] signalConditionsASAP(MultisessionFuture, pos=1) ...
  [22:51:46.884] - nx: 2
  [22:51:46.884] - relay: TRUE
  [22:51:46.884] - stdout: TRUE
  [22:51:46.885] - signal: TRUE
  [22:51:46.885] - resignal: FALSE
  [22:51:46.885] - force: FALSE
  [22:51:46.886] - relayed: [n=2] FALSE, FALSE
  [22:51:46.886] - queued futures: [n=2] FALSE, FALSE
  [22:51:46.886]  - until=1
  [22:51:46.887]  - relaying element #1
  [22:51:46.887] result() for ClusterFuture ...
  [22:51:46.887] - result already collected: FutureResult
  [22:51:46.888] result() for ClusterFuture ... done
  [22:51:46.888] result() for ClusterFuture ...
  [22:51:46.889] - result already collected: FutureResult
  [22:51:46.889] result() for ClusterFuture ... done
  [22:51:46.890] result() for ClusterFuture ...
  [22:51:46.890] - result already collected: FutureResult
  [22:51:46.890] result() for ClusterFuture ... done
  [22:51:46.903] result() for ClusterFuture ...
  [22:51:46.903] - result already collected: FutureResult
  [22:51:46.904] result() for ClusterFuture ... done
  [22:51:46.904] - relayed: [n=2] TRUE, FALSE
  [22:51:46.904] - queued futures: [n=2] TRUE, FALSE
  [22:51:46.905] signalConditionsASAP(MultisessionFuture, pos=1) ... done
  [22:51:46.905]  length: 1 (resolved future 1)
  [22:51:47.032] receiveMessageFromWorker() for ClusterFuture ...
  [22:51:47.032] - Validating connection of MultisessionFuture
  [22:51:47.033] - received message: FutureResult
  [22:51:47.033] - Received FutureResult
  [22:51:47.034] - Erased future from FutureRegistry
  [22:51:47.034] result() for ClusterFuture ...
  [22:51:47.034] - result already collected: FutureResult
  [22:51:47.035] result() for ClusterFuture ... done
  [22:51:47.035] receiveMessageFromWorker() for ClusterFuture ... done
  [22:51:47.035] Future #2
  [22:51:47.036] result() for ClusterFuture ...
  [22:51:47.036] - result already collected: FutureResult
  [22:51:47.036] result() for ClusterFuture ... done
  [22:51:47.037] result() for ClusterFuture ...
  [22:51:47.037] - result already collected: FutureResult
  [22:51:47.038] result() for ClusterFuture ... done
  [22:51:47.038] signalConditionsASAP(MultisessionFuture, pos=2) ...
  [22:51:47.038] - nx: 2
  [22:51:47.039] - relay: TRUE
  [22:51:47.039] - stdout: TRUE
  [22:51:47.039] - signal: TRUE
  [22:51:47.040] - resignal: FALSE
  [22:51:47.040] - force: FALSE
  [22:51:47.040] - relayed: [n=2] TRUE, FALSE
  [22:51:47.040] - queued futures: [n=2] TRUE, FALSE
  [22:51:47.041]  - until=2
  [22:51:47.041]  - relaying element #2
  [22:51:47.041] result() for ClusterFuture ...
  [22:51:47.042] - result already collected: FutureResult
  [22:51:47.042] result() for ClusterFuture ... done
  [22:51:47.042] result() for ClusterFuture ...
  [22:51:47.043] - result already collected: FutureResult
  [22:51:47.043] result() for ClusterFuture ... done
  [22:51:47.043] result() for ClusterFuture ...
  [22:51:47.044] - result already collected: FutureResult
  [22:51:47.044] result() for ClusterFuture ... done
  [22:51:47.044] result() for ClusterFuture ...
  [22:51:47.045] - result already collected: FutureResult
  [22:51:47.045] result() for ClusterFuture ... done
  [22:51:47.045] - relayed: [n=2] TRUE, TRUE
  [22:51:47.045] - queued futures: [n=2] TRUE, TRUE
  [22:51:47.046] signalConditionsASAP(MultisessionFuture, pos=2) ... done
  [22:51:47.046]  length: 0 (resolved future 2)
  [22:51:47.063] Relaying remaining futures
  [22:51:47.063] signalConditionsASAP(NULL, pos=0) ...
  [22:51:47.063] - nx: 2
  [22:51:47.064] - relay: TRUE
  [22:51:47.064] - stdout: TRUE
  [22:51:47.064] - signal: TRUE
  [22:51:47.064] - resignal: FALSE
  [22:51:47.065] - force: FALSE
  [22:51:47.065] - relayed: [n=2] TRUE, TRUE
  [22:51:47.065] - queued futures: [n=2] TRUE, TRUE
   - flush all
  [22:51:47.070] - relayed: [n=2] TRUE, TRUE
  [22:51:47.070] - queued futures: [n=2] TRUE, TRUE
  [22:51:47.070] signalConditionsASAP(NULL, pos=0) ... done
  [22:51:47.071] resolve() on list ... DONE
  [22:51:47.071] - collecting values of futures
  [22:51:47.071] result() for ClusterFuture ...
  [22:51:47.072] - result already collected: FutureResult
  [22:51:47.072] result() for ClusterFuture ... done
  [22:51:47.072] result() for ClusterFuture ...
  [22:51:47.073] - result already collected: FutureResult
  [22:51:47.073] result() for ClusterFuture ... done
  [22:51:47.073] result() for ClusterFuture ...
  [22:51:47.074] - result already collected: FutureResult
  [22:51:47.074] result() for ClusterFuture ... done
  [22:51:47.074] result() for ClusterFuture ...
  [22:51:47.075] - result already collected: FutureResult
  [22:51:47.075] result() for ClusterFuture ... done
  [22:51:47.075] - accumulating results
  [22:51:47.078] - processing errors (handler = 'stop')
  <simpleError in {    doFuture::registerDoFuture()    lapply(seq_along(...future.x_ii), FUN = function(jj) {        ...future.x_jj <- ...future.x_ii[[jj]]        i <- NULL        ...future.env <- environment()        local({            for (name in names(...future.x_jj)) {                assign(name, ...future.x_jj[[name]], envir = ...future.env,                   inherits = FALSE)            }        })        tryCatch({            if (i%%2 == 0)                 stop(sprintf("Index error ('stop'), because i = %d",                   i))            dnorm(i, mean = mu, sd = sigma)        }, error = identity)    })}: task 2 failed - "Index error ('stop'), because i = 2">
  - plan('multisession') ... DONE
  - plan('cluster') ...
  [22:51:47.080] plan(): Setting new future strategy stack:
  [22:51:47.080] List of future strategies:
  [22:51:47.080] 1. cluster:
  [22:51:47.080]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableWorkers(), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:51:47.080]    - tweaked: FALSE
  [22:51:47.080]    - call: plan(strategy)
  [22:51:47.083] plan(): plan_init() of 'cluster', 'multiprocess', 'future', 'function' ...
  [22:51:47.083] cluster:
  [22:51:47.083] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableWorkers(), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [22:51:47.083] - tweaked: FALSE
  [22:51:47.083] - call: plan(strategy)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 37248
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpLnkGbF/future.parent=16445.403d3bc7fc6a.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpLnkGbF/future.parent=16445.403d3bc7fc6a.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,errors.R:16445:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpLnkGbF/future.parent=16445.403d3bc7fc6a.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=37248 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  [local output] Detected a warning from socketConnection(): 'port 37248 cannot be opened'
  Warning in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  :
    port 37248 cannot be opened
  Killing worker process (PID 18988) if still alive
  [22:51:48.610] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(16445, signal = 0L)
  [1] TRUE
  Call: tools::pskill(16445, signal = 0L)
  [1] TRUE
  [22:51:48.611] - success
  [22:51:48.611] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 18988) was successfully killed: TRUE
  Error in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  : 
    Failed to launch and connect to R worker on local machine 'localhost' from local machine 'gimli'.
   * The error produced by socketConnection() was: 'cannot open the connection'
   * In addition, socketConnection() produced 1 warning(s):
     - Warning #1: 'port 37248 cannot be opened' (which suggests that this port is either already occupied by another process or blocked by the firewall on your local machine)
   * The localhost socket connection that failed to connect to the R worker used port 37248 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=foreach,errors.R:16445:gimli:hornik' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpLnkGbF/future.parent=16445.403d3bc7fc6a.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=37248 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 18988) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'outfile=NULL' to see output from worker.
  Calls: plan ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted