Running ‘000.sessionDetails.R’ [9s/11s]
  Running ‘ClusterRegistry.R’ [4s/62s]
  Running ‘Future-class.R’ [2s/27s]
  Running ‘FutureError.R’
  Running ‘FutureGlobals.R’
  Running ‘FutureRegistry.R’
  Running ‘as.cluster.R’ [1s/22s]
  Running ‘availableCores.R’
  Running ‘availableWorkers.R’
  Running ‘backtrace.R’
  Running ‘cluster-missing-future-pkg.R’
  Running ‘cluster.R’ [9s/150s]
  Running ‘constant.R’
  Running ‘demo.R’ [12s/36s]
  Running ‘dotdotdot.R’ [2s/23s]
  Running ‘early-signaling.R’ [3s/49s]
  Running ‘future,labels.R’
  Running ‘future.R’
  Running ‘futureAssign.R’ [3s/24s]
  Running ‘futureAssign_OP.R’ [4s/26s]
  Running ‘futureAssign_OP_with_environment.R’
  Running ‘futureAssign_OP_with_listenv.R’
  Running ‘futureCall.R’ [5s/36s]
  Running ‘futureOf.R’
  Running ‘futureOf_with_environment.R’
  Running ‘futureOf_with_listenv.R’
  Running ‘futures.R’ [24s/269s]
  Running ‘globals,NSE.R’
  Running ‘globals,formulas.R’ [5s/59s]
  Running ‘globals,manual.R’
  Running ‘globals,resolve.R’ [2s/56s]
  Running ‘globals,subassignment.R’ [4s/52s]
  Running ‘globals,toolarge.R’ [2s/55s]
  Running ‘globals,tricky.R’ [9s/58s]
  Running ‘globals,tricky_recursive.R’
  Running ‘globalsOf,tweaks.R’
  Running ‘immediateCondition.R’
  Running ‘invalid-owner.R’ [2s/35s]
  Running ‘makeClusterPSOCK.R’ [1s/17s]
  Running ‘mandelbrot.R’
  Running ‘mpi.R’
  Running ‘multicore,multithreading.R’
  Running ‘multicore.R’
  Running ‘multiprocess.R’
  Running ‘multisession.R’ [6s/78s]
  Running ‘nbrOfWorkers.R’ [6s/97s]
  Running ‘nested_futures,mc.cores.R’ [7s/163s]
  Running ‘nested_futures.R’
  Running ‘non-exportable,connections.R’ [2s/24s]
  Running ‘objectSize.R’
  Running ‘plan.R’ [9s/24s]
  Running ‘relaying.R’
  Running ‘remote.R’ [2s/27s]
  Running ‘requestCore.R’
  Running ‘requestNode.R’ [2s/42s]
  Running ‘reserved-keyword-functions.R’
  Running ‘resolve.R’
  Running ‘resolved-non-blocking-test.R’ [4s/88s]
  Running ‘rng.R’ [14s/44s]
  Running ‘sequential.R’
  Running ‘sessionDetails.R’
  Running ‘startup.R’ [3s/51s]
  Running ‘stdout.R’ [3s/27s]
  Running ‘transparent.R’
  Running ‘tweak.R’
  Running ‘utils.R’ [9s/11s]
  Running ‘uuid.R’
  Running ‘whichIndex.R’
Running the tests in ‘tests/multicore,multithreading.R’ failed.
Complete output:
  > source("incl/start.R")
  [16:46:14.566] plan(): Setting new future strategy stack:
  [16:46:14.581] List of future strategies:
  [16:46:14.581] 1. sequential:
  [16:46:14.581]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [16:46:14.581]    - tweaked: FALSE
  [16:46:14.581]    - call: future::plan("sequential")
  [16:46:14.584] plan(): nbrOfWorkers() = 1
  > library("listenv")
  > plan(multicore)
  [16:46:14.669] plan(): Setting new future strategy stack:
  [16:46:14.670] List of future strategies:
  [16:46:14.670] 1. multicore:
  [16:46:14.670]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [16:46:14.670]    - tweaked: FALSE
  [16:46:14.670]    - call: plan(multicore)
  [16:46:14.750] plan(): nbrOfWorkers() = 2
  > 
  > message("*** multicore() and multi-threading ...")
  *** multicore() and multi-threading ...
  > 
  > message("supportsMulticore(): ", sQuote(supportsMulticore()))
  supportsMulticore(): 'TRUE'
  > message("availableCores('multicore'): ", sQuote(availableCores("multicore")))
  availableCores('multicore'): '2'
  > message("supports_omp_threads(): ", sQuote(supports_omp_threads()))
  [16:46:14.901] supports_omp_threads() = TRUE
  supports_omp_threads(): 'TRUE'
  > 
  > if (supportsMulticore() && availableCores("multicore") >=2 && supports_omp_threads()) {
  +   for (enable in c(TRUE, FALSE)) {
  +     options(future.fork.multithreading.enable = enable)
  + 
  +     message(sprintf("'future.fork.multithreading.enable' = %s ...", enable))
  + 
  +     f <- future(RhpcBLASctl::omp_get_max_threads())
  +     nthreads <- value(f)
  +     cat(sprintf("Number of OpenMP threads in %s future: %d\n", sQuote(class(f)[1]), nthreads))
  + 
  +     ## Assert that single-threading was set?
  +     if (enable) {
  +       stopifnot(enable && nthreads > 1L)
  +     } else {
  +       stopifnot(!enable && nthreads == 1L)
  +     }
  +       
  +     message(sprintf("'future.fork.multithreading.enable' = %s ... DONE", enable))
  +   } ## for (enable ...)
  + } ## if (requireNamespace("RhpcBLASctl", ...)) {
  [16:46:14.924] supports_omp_threads() = TRUE
  'future.fork.multithreading.enable' = TRUE ...
  [16:46:15.012] getGlobalsAndPackages() ...
  [16:46:15.026] Searching for globals...
  [16:46:15.052] - globals found: [1] '::'
  [16:46:15.053] Searching for globals ... DONE
  [16:46:15.054] Resolving globals: FALSE
  [16:46:15.055] 
  [16:46:15.056] 
  [16:46:15.056] getGlobalsAndPackages() ... DONE
  [16:46:15.063] Packages needed by the future expression (n = 0): <none>
  [16:46:15.063] Packages needed by future strategies (n = 0): <none>
  [16:46:15.086] {
  [16:46:15.086]     {
  [16:46:15.086]         ...future.startTime <- base::Sys.time()
  [16:46:15.086]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [16:46:15.086]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [16:46:15.086]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [16:46:15.086]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [16:46:15.086]             future.resolve.recursive = NULL, width = 80L)
  [16:46:15.086]         {
  [16:46:15.086]             {
  [16:46:15.086]                 {
  [16:46:15.086]                   has_future <- base::requireNamespace("future", 
  [16:46:15.086]                     quietly = TRUE)
  [16:46:15.086]                   version <- if (has_future) 
  [16:46:15.086]                     utils::packageVersion("future")
  [16:46:15.086]                   else NULL
  [16:46:15.086]                   if (!has_future || version < "1.8.0") {
  [16:46:15.086]                     info <- base::c(r_version = base::gsub("R version ", 
  [16:46:15.086]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [16:46:15.086]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [16:46:15.086]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [16:46:15.086]                         "release", "version")], collapse = " "), 
  [16:46:15.086]                       hostname = base::Sys.info()[["nodename"]])
  [16:46:15.086]                     info <- base::sprintf("%s: %s", base::names(info), 
  [16:46:15.086]                       info)
  [16:46:15.086]                     info <- base::paste(info, collapse = "; ")
  [16:46:15.086]                     if (!has_future) {
  [16:46:15.086]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [16:46:15.086]                         info)
  [16:46:15.086]                     }
  [16:46:15.086]                     else {
  [16:46:15.086]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [16:46:15.086]                         info, version)
  [16:46:15.086]                     }
  [16:46:15.086]                     base::stop(msg)
  [16:46:15.086]                   }
  [16:46:15.086]                 }
  [16:46:15.086]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [16:46:15.086]                 base::options(mc.cores = 1L)
  [16:46:15.086]             }
  [16:46:15.086]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [16:46:15.086]         }
  [16:46:15.086]     }
  [16:46:15.086]     if (base::is.na(TRUE)) {
  [16:46:15.086]     }
  [16:46:15.086]     else {
  [16:46:15.086]         if (TRUE) {
  [16:46:15.086]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [16:46:15.086]                 open = "w")
  [16:46:15.086]         }
  [16:46:15.086]         else {
  [16:46:15.086]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [16:46:15.086]                 windows = "NUL", "/dev/null"), open = "w")
  [16:46:15.086]         }
  [16:46:15.086]         base::sink(...future.stdout, type = "output", split = FALSE)
  [16:46:15.086]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [16:46:15.086]             base::sink(type = "output", split = FALSE)
  [16:46:15.086]             base::close(...future.stdout)
  [16:46:15.086]         }, add = TRUE)
  [16:46:15.086]     }
  [16:46:15.086]     ...future.frame <- base::sys.nframe()
  [16:46:15.086]     ...future.conditions <- base::list()
  [16:46:15.086]     ...future.rng <- base::globalenv()$.Random.seed
  [16:46:15.086]     ...future.result <- base::tryCatch({
  [16:46:15.086]         base::withCallingHandlers({
  [16:46:15.086]             ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
  [16:46:15.086]             future::FutureResult(value = ...future.value$value, 
  [16:46:15.086]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [16:46:15.086]                   ...future.rng), started = ...future.startTime, 
  [16:46:15.086]                 version = "1.8")
  [16:46:15.086]         }, condition = base::local({
  [16:46:15.086]             c <- base::c
  [16:46:15.086]             inherits <- base::inherits
  [16:46:15.086]             invokeRestart <- base::invokeRestart
  [16:46:15.086]             length <- base::length
  [16:46:15.086]             list <- base::list
  [16:46:15.086]             seq.int <- base::seq.int
  [16:46:15.086]             signalCondition <- base::signalCondition
  [16:46:15.086]             sys.calls <- base::sys.calls
  [16:46:15.086]             Sys.time <- base::Sys.time
  [16:46:15.086]             `[[` <- base::`[[`
  [16:46:15.086]             `+` <- base::`+`
  [16:46:15.086]             `<<-` <- base::`<<-`
  [16:46:15.086]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [16:46:15.086]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [16:46:15.086]                   3L)]
  [16:46:15.086]             }
  [16:46:15.086]             function(cond) {
  [16:46:15.086]                 if (inherits(cond, "error")) {
  [16:46:15.086]                   ...future.conditions[[length(...future.conditions) + 
  [16:46:15.086]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [16:46:15.086]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [16:46:15.086]                   signalCondition(cond)
  [16:46:15.086]                 }
  [16:46:15.086]                 else if (inherits(cond, "condition")) {
  [16:46:15.086]                   signal <- FALSE && inherits(cond, character(0))
  [16:46:15.086]                   ...future.conditions[[length(...future.conditions) + 
  [16:46:15.086]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [16:46:15.086]                   if (!signal) {
  [16:46:15.086]                     muffleCondition <- function (cond) 
  [16:46:15.086]                     {
  [16:46:15.086]                       inherits <- base::inherits
  [16:46:15.086]                       invokeRestart <- base::invokeRestart
  [16:46:15.086]                       muffled <- FALSE
  [16:46:15.086]                       if (inherits(cond, "message")) {
  [16:46:15.086]                         invokeRestart("muffleMessage")
  [16:46:15.086]                         muffled <- TRUE
  [16:46:15.086]                       }
  [16:46:15.086]                       else if (inherits(cond, "warning")) {
  [16:46:15.086]                         invokeRestart("muffleWarning")
  [16:46:15.086]                         muffled <- TRUE
  [16:46:15.086]                       }
  [16:46:15.086]                       else if (inherits(cond, "condition")) {
  [16:46:15.086]                         computeRestarts <- base::computeRestarts
  [16:46:15.086]                         grepl <- base::grepl
  [16:46:15.086]                         is.null <- base::is.null
  [16:46:15.086]                         restarts <- computeRestarts(cond)
  [16:46:15.086]                         for (restart in restarts) {
  [16:46:15.086]                           name <- restart$name
  [16:46:15.086]                           if (is.null(name)) 
  [16:46:15.086]                             next
  [16:46:15.086]                           if (!grepl("^muffle", name)) 
  [16:46:15.086]                             next
  [16:46:15.086]                           invokeRestart(restart)
  [16:46:15.086]                           muffled <- TRUE
  [16:46:15.086]                           break
  [16:46:15.086]                         }
  [16:46:15.086]                       }
  [16:46:15.086]                       invisible(muffled)
  [16:46:15.086]                     }
  [16:46:15.086]                     muffleCondition(cond)
  [16:46:15.086]                   }
  [16:46:15.086]                 }
  [16:46:15.086]             }
  [16:46:15.086]         }))
  [16:46:15.086]     }, error = function(ex) {
  [16:46:15.086]         base::structure(base::list(value = NULL, visible = NULL, 
  [16:46:15.086]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [16:46:15.086]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [16:46:15.086]     }, finally = {
  [16:46:15.086]         {
  [16:46:15.086]             {
  [16:46:15.086]                 base::options(mc.cores = ...future.mc.cores.old)
  [16:46:15.086]             }
  [16:46:15.086]             future::plan(list(function (expr, envir = parent.frame(), 
  [16:46:15.086]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [16:46:15.086]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [16:46:15.086]                 earlySignal = FALSE, label = NULL, ...) 
  [16:46:15.086]             {
  [16:46:15.086]                 if (substitute) 
  [16:46:15.086]                   expr <- substitute(expr)
  [16:46:15.086]                 if (is.function(workers)) 
  [16:46:15.086]                   workers <- workers()
  [16:46:15.086]                 workers <- as.integer(workers)
  [16:46:15.086]                 stop_if_not(is.finite(workers), workers >= 1L)
  [16:46:15.086]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [16:46:15.086]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [16:46:15.086]                     lazy = lazy, seed = seed, globals = globals, 
  [16:46:15.086]                     local = TRUE, label = label, ...))
  [16:46:15.086]                 }
  [16:46:15.086]                 oopts <- options(mc.cores = workers)
  [16:46:15.086]                 on.exit(options(oopts))
  [16:46:15.086]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [16:46:15.086]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [16:46:15.086]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [16:46:15.086]                   label = label, ...)
  [16:46:15.086]                 if (!future$lazy) 
  [16:46:15.086]                   future <- run(future)
  [16:46:15.086]                 invisible(future)
  [16:46:15.086]             }), .cleanup = FALSE, .init = FALSE)
  [16:46:15.086]         }
  [16:46:15.086]         base::options(...future.oldOptions)
  [16:46:15.086]     })
  [16:46:15.086]     Sys.time
  [16:46:15.086]     if (base::is.na(TRUE)) {
  [16:46:15.086]     }
  [16:46:15.086]     else {
  [16:46:15.086]         base::sink(type = "output", split = FALSE)
  [16:46:15.086]         if (TRUE) {
  [16:46:15.086]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [16:46:15.086]         }
  [16:46:15.086]         else {
  [16:46:15.086]             ...future.result["stdout"] <- base::list(NULL)
  [16:46:15.086]         }
  [16:46:15.086]         base::close(...future.stdout)
  [16:46:15.086]         ...future.stdout <- NULL
  [16:46:15.086]     }
  [16:46:15.086]     ...future.result$conditions <- ...future.conditions
  [16:46:15.086]     ...future.result
  [16:46:15.086] }
  [16:46:15.105] requestCore(): workers = 2
  [16:46:15.113] MulticoreFuture started
  [16:46:15.135] plan(): Setting new future strategy stack:
  [16:46:15.136] List of future strategies:
  [16:46:15.136] 1. sequential:
  [16:46:15.136]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [16:46:15.136]    - tweaked: FALSE
  [16:46:15.136]    - call: NULL
  [16:46:15.147] plan(): nbrOfWorkers() = 1
  [16:46:15.152] plan(): Setting new future strategy stack:
  [16:46:15.152] List of future strategies:
  [16:46:15.152] 1. multicore:
  [16:46:15.152]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [16:46:15.152]    - tweaked: FALSE
  [16:46:15.152]    - call: plan(multicore)
  [16:46:15.169] plan(): nbrOfWorkers() = 2
  Number of OpenMP threads in 'MulticoreFuture' future: 24
  'future.fork.multithreading.enable' = TRUE ... DONE
  'future.fork.multithreading.enable' = FALSE ...
  [16:46:15.201] getGlobalsAndPackages() ...
  [16:46:15.201] Searching for globals...
  [16:46:15.204] - globals found: [1] '::'
  [16:46:15.205] Searching for globals ... DONE
  [16:46:15.205] Resolving globals: FALSE
  [16:46:15.206] 
  [16:46:15.207] 
  [16:46:15.207] getGlobalsAndPackages() ... DONE
  [16:46:15.208] - Evaluate future in single-threaded mode ...
  [16:46:15.209] supports_omp_threads() = TRUE
  [16:46:15.223]   - Force single-threaded processing for OpenMP
  [16:46:15.223] - Evaluate future in single-threaded mode ... DONE
  [16:46:15.227] Packages needed by the future expression (n = 0): <none>
  [16:46:15.228] Packages needed by future strategies (n = 0): <none>
  [16:46:15.250] {
  [16:46:15.250]     {
  [16:46:15.250]         ...future.startTime <- base::Sys.time()
  [16:46:15.250]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [16:46:15.250]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [16:46:15.250]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [16:46:15.250]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [16:46:15.250]             future.resolve.recursive = NULL, width = 80L)
  [16:46:15.250]         {
  [16:46:15.250]             {
  [16:46:15.250]                 {
  [16:46:15.250]                   has_future <- base::requireNamespace("future", 
  [16:46:15.250]                     quietly = TRUE)
  [16:46:15.250]                   version <- if (has_future) 
  [16:46:15.250]                     utils::packageVersion("future")
  [16:46:15.250]                   else NULL
  [16:46:15.250]                   if (!has_future || version < "1.8.0") {
  [16:46:15.250]                     info <- base::c(r_version = base::gsub("R version ", 
  [16:46:15.250]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [16:46:15.250]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [16:46:15.250]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [16:46:15.250]                         "release", "version")], collapse = " "), 
  [16:46:15.250]                       hostname = base::Sys.info()[["nodename"]])
  [16:46:15.250]                     info <- base::sprintf("%s: %s", base::names(info), 
  [16:46:15.250]                       info)
  [16:46:15.250]                     info <- base::paste(info, collapse = "; ")
  [16:46:15.250]                     if (!has_future) {
  [16:46:15.250]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [16:46:15.250]                         info)
  [16:46:15.250]                     }
  [16:46:15.250]                     else {
  [16:46:15.250]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [16:46:15.250]                         info, version)
  [16:46:15.250]                     }
  [16:46:15.250]                     base::stop(msg)
  [16:46:15.250]                   }
  [16:46:15.250]                 }
  [16:46:15.250]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [16:46:15.250]                 base::options(mc.cores = 1L)
  [16:46:15.250]             }
  [16:46:15.250]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [16:46:15.250]         }
  [16:46:15.250]     }
  [16:46:15.250]     if (base::is.na(TRUE)) {
  [16:46:15.250]     }
  [16:46:15.250]     else {
  [16:46:15.250]         if (TRUE) {
  [16:46:15.250]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [16:46:15.250]                 open = "w")
  [16:46:15.250]         }
  [16:46:15.250]         else {
  [16:46:15.250]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [16:46:15.250]                 windows = "NUL", "/dev/null"), open = "w")
  [16:46:15.250]         }
  [16:46:15.250]         base::sink(...future.stdout, type = "output", split = FALSE)
  [16:46:15.250]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [16:46:15.250]             base::sink(type = "output", split = FALSE)
  [16:46:15.250]             base::close(...future.stdout)
  [16:46:15.250]         }, add = TRUE)
  [16:46:15.250]     }
  [16:46:15.250]     ...future.frame <- base::sys.nframe()
  [16:46:15.250]     ...future.conditions <- base::list()
  [16:46:15.250]     ...future.rng <- base::globalenv()$.Random.seed
  [16:46:15.250]     ...future.result <- base::tryCatch({
  [16:46:15.250]         base::withCallingHandlers({
  [16:46:15.250]             ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
  [16:46:15.250]             future::FutureResult(value = ...future.value$value, 
  [16:46:15.250]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [16:46:15.250]                   ...future.rng), started = ...future.startTime, 
  [16:46:15.250]                 version = "1.8")
  [16:46:15.250]         }, condition = base::local({
  [16:46:15.250]             c <- base::c
  [16:46:15.250]             inherits <- base::inherits
  [16:46:15.250]             invokeRestart <- base::invokeRestart
  [16:46:15.250]             length <- base::length
  [16:46:15.250]             list <- base::list
  [16:46:15.250]             seq.int <- base::seq.int
  [16:46:15.250]             signalCondition <- base::signalCondition
  [16:46:15.250]             sys.calls <- base::sys.calls
  [16:46:15.250]             Sys.time <- base::Sys.time
  [16:46:15.250]             `[[` <- base::`[[`
  [16:46:15.250]             `+` <- base::`+`
  [16:46:15.250]             `<<-` <- base::`<<-`
  [16:46:15.250]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [16:46:15.250]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [16:46:15.250]                   3L)]
  [16:46:15.250]             }
  [16:46:15.250]             function(cond) {
  [16:46:15.250]                 if (inherits(cond, "error")) {
  [16:46:15.250]                   ...future.conditions[[length(...future.conditions) + 
  [16:46:15.250]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [16:46:15.250]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [16:46:15.250]                   signalCondition(cond)
  [16:46:15.250]                 }
  [16:46:15.250]                 else if (inherits(cond, "condition")) {
  [16:46:15.250]                   signal <- FALSE && inherits(cond, character(0))
  [16:46:15.250]                   ...future.conditions[[length(...future.conditions) + 
  [16:46:15.250]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [16:46:15.250]                   if (!signal) {
  [16:46:15.250]                     muffleCondition <- function (cond) 
  [16:46:15.250]                     {
  [16:46:15.250]                       inherits <- base::inherits
  [16:46:15.250]                       invokeRestart <- base::invokeRestart
  [16:46:15.250]                       muffled <- FALSE
  [16:46:15.250]                       if (inherits(cond, "message")) {
  [16:46:15.250]                         invokeRestart("muffleMessage")
  [16:46:15.250]                         muffled <- TRUE
  [16:46:15.250]                       }
  [16:46:15.250]                       else if (inherits(cond, "warning")) {
  [16:46:15.250]                         invokeRestart("muffleWarning")
  [16:46:15.250]                         muffled <- TRUE
  [16:46:15.250]                       }
  [16:46:15.250]                       else if (inherits(cond, "condition")) {
  [16:46:15.250]                         computeRestarts <- base::computeRestarts
  [16:46:15.250]                         grepl <- base::grepl
  [16:46:15.250]                         is.null <- base::is.null
  [16:46:15.250]                         restarts <- computeRestarts(cond)
  [16:46:15.250]                         for (restart in restarts) {
  [16:46:15.250]                           name <- restart$name
  [16:46:15.250]                           if (is.null(name)) 
  [16:46:15.250]                             next
  [16:46:15.250]                           if (!grepl("^muffle", name)) 
  [16:46:15.250]                             next
  [16:46:15.250]                           invokeRestart(restart)
  [16:46:15.250]                           muffled <- TRUE
  [16:46:15.250]                           break
  [16:46:15.250]                         }
  [16:46:15.250]                       }
  [16:46:15.250]                       invisible(muffled)
  [16:46:15.250]                     }
  [16:46:15.250]                     muffleCondition(cond)
  [16:46:15.250]                   }
  [16:46:15.250]                 }
  [16:46:15.250]             }
  [16:46:15.250]         }))
  [16:46:15.250]     }, error = function(ex) {
  [16:46:15.250]         base::structure(base::list(value = NULL, visible = NULL, 
  [16:46:15.250]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [16:46:15.250]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [16:46:15.250]     }, finally = {
  [16:46:15.250]         {
  [16:46:15.250]             {
  [16:46:15.250]                 base::options(mc.cores = ...future.mc.cores.old)
  [16:46:15.250]             }
  [16:46:15.250]             future::plan(list(function (expr, envir = parent.frame(), 
  [16:46:15.250]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [16:46:15.250]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [16:46:15.250]                 earlySignal = FALSE, label = NULL, ...) 
  [16:46:15.250]             {
  [16:46:15.250]                 if (substitute) 
  [16:46:15.250]                   expr <- substitute(expr)
  [16:46:15.250]                 if (is.function(workers)) 
  [16:46:15.250]                   workers <- workers()
  [16:46:15.250]                 workers <- as.integer(workers)
  [16:46:15.250]                 stop_if_not(is.finite(workers), workers >= 1L)
  [16:46:15.250]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [16:46:15.250]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [16:46:15.250]                     lazy = lazy, seed = seed, globals = globals, 
  [16:46:15.250]                     local = TRUE, label = label, ...))
  [16:46:15.250]                 }
  [16:46:15.250]                 oopts <- options(mc.cores = workers)
  [16:46:15.250]                 on.exit(options(oopts))
  [16:46:15.250]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [16:46:15.250]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [16:46:15.250]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [16:46:15.250]                   label = label, ...)
  [16:46:15.250]                 if (!future$lazy) 
  [16:46:15.250]                   future <- run(future)
  [16:46:15.250]                 invisible(future)
  [16:46:15.250]             }), .cleanup = FALSE, .init = FALSE)
  [16:46:15.250]         }
  [16:46:15.250]         base::options(...future.oldOptions)
  [16:46:15.250]     })
  [16:46:15.250]     Sys.time
  [16:46:15.250]     if (base::is.na(TRUE)) {
  [16:46:15.250]     }
  [16:46:15.250]     else {
  [16:46:15.250]         base::sink(type = "output", split = FALSE)
  [16:46:15.250]         if (TRUE) {
  [16:46:15.250]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [16:46:15.250]         }
  [16:46:15.250]         else {
  [16:46:15.250]             ...future.result["stdout"] <- base::list(NULL)
  [16:46:15.250]         }
  [16:46:15.250]         base::close(...future.stdout)
  [16:46:15.250]         ...future.stdout <- NULL
  [16:46:15.250]     }
  [16:46:15.250]     ...future.result$conditions <- ...future.conditions
  [16:46:15.250]     ...future.result
  [16:46:15.250] }
  [16:46:15.256] requestCore(): workers = 2
  [16:46:15.276] MulticoreFuture started
  [16:46:15.288] plan(): Setting new future strategy stack:
  [16:46:15.289] List of future strategies:
  [16:46:15.289] 1. sequential:
  [16:46:15.289]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [16:46:15.289]    - tweaked: FALSE
  [16:46:15.289]    - call: NULL
  [16:46:15.356] plan(): nbrOfWorkers() = 1
  [16:46:15.361] plan(): Setting new future strategy stack:
  [16:46:15.362] List of future strategies:
  [16:46:15.362] 1. multicore:
  [16:46:15.362]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [16:46:15.362]    - tweaked: FALSE
  [16:46:15.362]    - call: plan(multicore)
  [16:46:15.369] plan(): nbrOfWorkers() = 2
  Number of OpenMP threads in 'MulticoreFuture' future: 24
  Error: !enable && nthreads == 1L is not TRUE
  Execution halted