CRAN Package Check Results for Package future

Last updated on 2020-02-20 00:54:13 CET.

Flavor Version Tinstall Tcheck Ttotal Status Flags
r-devel-linux-x86_64-debian-clang 1.16.0 8.31 230.49 238.80 ERROR
r-devel-linux-x86_64-debian-gcc 1.16.0 7.64 182.01 189.65 OK
r-devel-linux-x86_64-fedora-clang 1.16.0 293.06 ERROR
r-devel-linux-x86_64-fedora-gcc 1.16.0 291.90 OK
r-devel-windows-ix86+x86_64 1.16.0 15.00 344.00 359.00 OK
r-devel-windows-ix86+x86_64-gcc8 1.16.0 25.00 511.00 536.00 OK
r-patched-linux-x86_64 1.16.0 7.68 215.59 223.27 OK
r-patched-solaris-x86 1.16.0 106.20 OK --no-tests
r-release-linux-x86_64 1.16.0 7.50 215.25 222.75 OK
r-release-windows-ix86+x86_64 1.16.0 14.00 328.00 342.00 OK
r-release-osx-x86_64 1.16.0 OK
r-oldrel-windows-ix86+x86_64 1.16.0 12.00 319.00 331.00 OK
r-oldrel-osx-x86_64 1.16.0 OK

Check Details

Version: 1.16.0
Check: tests
Result: ERROR
     Running '000.sessionDetails.R' [8s/8s]
     Running 'ClusterRegistry.R' [3s/53s]
     Running 'Future-class.R' [2s/20s]
     Running 'FutureError.R' [1s/1s]
     Running 'FutureGlobals.R' [1s/1s]
     Running 'FutureRegistry.R' [1s/2s]
     Running 'as.cluster.R' [1s/19s]
     Running 'availableCores.R' [1s/1s]
     Running 'availableWorkers.R' [1s/1s]
     Running 'backtrace.R' [1s/3s]
     Running 'cluster-missing-future-pkg.R' [1s/3s]
     Running 'cluster.R' [7s/124s]
     Running 'constant.R' [1s/1s]
     Running 'demo.R' [9s/28s]
     Running 'dotdotdot.R' [2s/19s]
     Running 'early-signaling.R' [2s/40s]
     Running 'future,labels.R' [1s/1s]
     Running 'future.R' [1s/1s]
     Running 'futureAssign.R' [2s/19s]
     Running 'futureAssign_OP.R' [3s/20s]
     Running 'futureAssign_OP_with_environment.R' [1s/1s]
     Running 'futureAssign_OP_with_listenv.R' [1s/2s]
     Running 'futureCall.R' [4s/30s]
     Running 'futureOf.R' [1s/1s]
     Running 'futureOf_with_environment.R' [1s/1s]
     Running 'futureOf_with_listenv.R' [1s/1s]
     Running 'futures.R' [20s/152s]
     Running 'globals,NSE.R' [1s/1s]
     Running 'globals,formulas.R' [4s/23s]
     Running 'globals,manual.R' [2s/2s]
     Running 'globals,resolve.R' [2s/19s]
     Running 'globals,subassignment.R' [3s/22s]
     Running 'globals,toolarge.R' [1s/18s]
     Running 'globals,tricky.R' [7s/28s]
     Running 'globals,tricky_recursive.R' [1s/1s]
     Running 'globalsOf,tweaks.R' [1s/1s]
     Running 'immediateCondition.R' [1s/2s]
     Running 'invalid-owner.R' [2s/19s]
     Running 'makeClusterPSOCK.R' [1s/9s]
     Running 'mandelbrot.R' [1s/1s]
     Running 'mpi.R' [1s/1s]
     Running 'multicore,multithreading.R' [1s/1s]
     Running 'multicore.R' [1s/2s]
     Running 'multiprocess.R' [2s/2s]
     Running 'multisession.R' [5s/58s]
     Running 'nbrOfWorkers.R' [5s/75s]
     Running 'nested_futures,mc.cores.R' [6s/124s]
     Running 'nested_futures.R' [1s/1s]
     Running 'non-exportable,connections.R' [1s/19s]
     Running 'objectSize.R' [1s/1s]
     Running 'plan.R' [6s/19s]
     Running 'relaying.R' [1s/2s]
     Running 'remote.R' [1s/19s]
     Running 'requestCore.R' [1s/3s]
     Running 'requestNode.R' [2s/32s]
     Running 'reserved-keyword-functions.R' [1s/1s]
     Running 'resolve.R' [2s/4s]
     Running 'resolved-non-blocking-test.R' [3s/71s]
     Running 'rng.R' [12s/33s]
     Running 'sequential.R' [1s/1s]
     Running 'sessionDetails.R' [1s/1s]
     Running 'startup.R' [2s/37s]
     Running 'stdout.R' [3s/21s]
     Running 'transparent.R' [1s/1s]
     Running 'tweak.R' [1s/1s]
     Running 'utils.R' [8s/9s]
     Running 'uuid.R' [1s/2s]
     Running 'whichIndex.R' [1s/1s]
    Running the tests in 'tests/multicore,multithreading.R' failed.
    Complete output:
     > source("incl/start.R")
     [23:32:29.857] plan(): Setting new future strategy stack:
     [23:32:29.859] List of future strategies:
     [23:32:29.859] 1. sequential:
     [23:32:29.859] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [23:32:29.859] - tweaked: FALSE
     [23:32:29.859] - call: future::plan("sequential")
     [23:32:29.862] plan(): nbrOfWorkers() = 1
     > library("listenv")
     > plan(multicore)
     [23:32:29.894] plan(): Setting new future strategy stack:
     [23:32:29.895] List of future strategies:
     [23:32:29.895] 1. multicore:
     [23:32:29.895] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [23:32:29.895] - tweaked: FALSE
     [23:32:29.895] - call: plan(multicore)
     [23:32:29.940] 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()))
     [23:32:30.118] 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", ...)) {
     [23:32:30.121] supports_omp_threads() = TRUE
     'future.fork.multithreading.enable' = TRUE ...
     [23:32:30.178] getGlobalsAndPackages() ...
     [23:32:30.195] Searching for globals...
     [23:32:30.204] - globals found: [1] '::'
     [23:32:30.205] Searching for globals ... DONE
     [23:32:30.205] Resolving globals: FALSE
     [23:32:30.207]
     [23:32:30.207]
     [23:32:30.207] getGlobalsAndPackages() ... DONE
     [23:32:30.232] Packages needed by the future expression (n = 0): <none>
     [23:32:30.233] Packages needed by future strategies (n = 0): <none>
     [23:32:30.240] {
     [23:32:30.240] {
     [23:32:30.240] ...future.startTime <- base::Sys.time()
     [23:32:30.240] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [23:32:30.240] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [23:32:30.240] future.globals.method = NULL, future.globals.onMissing = NULL,
     [23:32:30.240] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [23:32:30.240] future.resolve.recursive = NULL, width = 80L)
     [23:32:30.240] {
     [23:32:30.240] {
     [23:32:30.240] {
     [23:32:30.240] has_future <- base::requireNamespace("future",
     [23:32:30.240] quietly = TRUE)
     [23:32:30.240] version <- if (has_future)
     [23:32:30.240] utils::packageVersion("future")
     [23:32:30.240] else NULL
     [23:32:30.240] if (!has_future || version < "1.8.0") {
     [23:32:30.240] info <- base::c(r_version = base::gsub("R version ",
     [23:32:30.240] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [23:32:30.240] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [23:32:30.240] os = base::paste(base::Sys.info()[base::c("sysname",
     [23:32:30.240] "release", "version")], collapse = " "),
     [23:32:30.240] hostname = base::Sys.info()[["nodename"]])
     [23:32:30.240] info <- base::sprintf("%s: %s", base::names(info),
     [23:32:30.240] info)
     [23:32:30.240] info <- base::paste(info, collapse = "; ")
     [23:32:30.240] if (!has_future) {
     [23:32:30.240] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [23:32:30.240] info)
     [23:32:30.240] }
     [23:32:30.240] else {
     [23:32:30.240] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [23:32:30.240] info, version)
     [23:32:30.240] }
     [23:32:30.240] base::stop(msg)
     [23:32:30.240] }
     [23:32:30.240] }
     [23:32:30.240] ...future.mc.cores.old <- base::getOption("mc.cores")
     [23:32:30.240] base::options(mc.cores = 1L)
     [23:32:30.240] }
     [23:32:30.240] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [23:32:30.240] }
     [23:32:30.240] }
     [23:32:30.240] if (base::is.na(TRUE)) {
     [23:32:30.240] }
     [23:32:30.240] else {
     [23:32:30.240] if (TRUE) {
     [23:32:30.240] ...future.stdout <- base::rawConnection(base::raw(0L),
     [23:32:30.240] open = "w")
     [23:32:30.240] }
     [23:32:30.240] else {
     [23:32:30.240] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [23:32:30.240] windows = "NUL", "/dev/null"), open = "w")
     [23:32:30.240] }
     [23:32:30.240] base::sink(...future.stdout, type = "output", split = FALSE)
     [23:32:30.240] base::on.exit(if (!base::is.null(...future.stdout)) {
     [23:32:30.240] base::sink(type = "output", split = FALSE)
     [23:32:30.240] base::close(...future.stdout)
     [23:32:30.240] }, add = TRUE)
     [23:32:30.240] }
     [23:32:30.240] ...future.frame <- base::sys.nframe()
     [23:32:30.240] ...future.conditions <- base::list()
     [23:32:30.240] ...future.rng <- base::globalenv()$.Random.seed
     [23:32:30.240] ...future.result <- base::tryCatch({
     [23:32:30.240] base::withCallingHandlers({
     [23:32:30.240] ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
     [23:32:30.240] future::FutureResult(value = ...future.value$value,
     [23:32:30.240] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [23:32:30.240] ...future.rng), started = ...future.startTime,
     [23:32:30.240] version = "1.8")
     [23:32:30.240] }, condition = base::local({
     [23:32:30.240] c <- base::c
     [23:32:30.240] inherits <- base::inherits
     [23:32:30.240] invokeRestart <- base::invokeRestart
     [23:32:30.240] length <- base::length
     [23:32:30.240] list <- base::list
     [23:32:30.240] seq.int <- base::seq.int
     [23:32:30.240] signalCondition <- base::signalCondition
     [23:32:30.240] sys.calls <- base::sys.calls
     [23:32:30.240] Sys.time <- base::Sys.time
     [23:32:30.240] `[[` <- base::`[[`
     [23:32:30.240] `+` <- base::`+`
     [23:32:30.240] `<<-` <- base::`<<-`
     [23:32:30.240] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [23:32:30.240] calls[seq.int(from = from + 12L, to = length(calls) -
     [23:32:30.240] 3L)]
     [23:32:30.240] }
     [23:32:30.240] function(cond) {
     [23:32:30.240] if (inherits(cond, "error")) {
     [23:32:30.240] ...future.conditions[[length(...future.conditions) +
     [23:32:30.240] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [23:32:30.240] cond$call), timestamp = Sys.time(), signaled = 0L)
     [23:32:30.240] signalCondition(cond)
     [23:32:30.240] }
     [23:32:30.240] else if (inherits(cond, "condition")) {
     [23:32:30.240] signal <- FALSE && inherits(cond, character(0))
     [23:32:30.240] ...future.conditions[[length(...future.conditions) +
     [23:32:30.240] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [23:32:30.240] if (!signal) {
     [23:32:30.240] muffleCondition <- function (cond)
     [23:32:30.240] {
     [23:32:30.240] inherits <- base::inherits
     [23:32:30.240] invokeRestart <- base::invokeRestart
     [23:32:30.240] muffled <- FALSE
     [23:32:30.240] if (inherits(cond, "message")) {
     [23:32:30.240] invokeRestart("muffleMessage")
     [23:32:30.240] muffled <- TRUE
     [23:32:30.240] }
     [23:32:30.240] else if (inherits(cond, "warning")) {
     [23:32:30.240] invokeRestart("muffleWarning")
     [23:32:30.240] muffled <- TRUE
     [23:32:30.240] }
     [23:32:30.240] else if (inherits(cond, "condition")) {
     [23:32:30.240] computeRestarts <- base::computeRestarts
     [23:32:30.240] grepl <- base::grepl
     [23:32:30.240] is.null <- base::is.null
     [23:32:30.240] restarts <- computeRestarts(cond)
     [23:32:30.240] for (restart in restarts) {
     [23:32:30.240] name <- restart$name
     [23:32:30.240] if (is.null(name))
     [23:32:30.240] next
     [23:32:30.240] if (!grepl("^muffle", name))
     [23:32:30.240] next
     [23:32:30.240] invokeRestart(restart)
     [23:32:30.240] muffled <- TRUE
     [23:32:30.240] break
     [23:32:30.240] }
     [23:32:30.240] }
     [23:32:30.240] invisible(muffled)
     [23:32:30.240] }
     [23:32:30.240] muffleCondition(cond)
     [23:32:30.240] }
     [23:32:30.240] }
     [23:32:30.240] }
     [23:32:30.240] }))
     [23:32:30.240] }, error = function(ex) {
     [23:32:30.240] base::structure(base::list(value = NULL, visible = NULL,
     [23:32:30.240] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [23:32:30.240] ...future.rng), version = "1.8"), class = "FutureResult")
     [23:32:30.240] }, finally = {
     [23:32:30.240] {
     [23:32:30.240] {
     [23:32:30.240] base::options(mc.cores = ...future.mc.cores.old)
     [23:32:30.240] }
     [23:32:30.240] future::plan(list(function (expr, envir = parent.frame(),
     [23:32:30.240] substitute = TRUE, lazy = FALSE, seed = NULL,
     [23:32:30.240] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [23:32:30.240] earlySignal = FALSE, label = NULL, ...)
     [23:32:30.240] {
     [23:32:30.240] if (substitute)
     [23:32:30.240] expr <- substitute(expr)
     [23:32:30.240] if (is.function(workers))
     [23:32:30.240] workers <- workers()
     [23:32:30.240] workers <- as.integer(workers)
     [23:32:30.240] stop_if_not(is.finite(workers), workers >= 1L)
     [23:32:30.240] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [23:32:30.240] return(sequential(expr, envir = envir, substitute = FALSE,
     [23:32:30.240] lazy = lazy, seed = seed, globals = globals,
     [23:32:30.240] local = TRUE, label = label, ...))
     [23:32:30.240] }
     [23:32:30.240] oopts <- options(mc.cores = workers)
     [23:32:30.240] on.exit(options(oopts))
     [23:32:30.240] future <- MulticoreFuture(expr = expr, envir = envir,
     [23:32:30.240] substitute = FALSE, lazy = lazy, seed = seed,
     [23:32:30.240] globals = globals, workers = workers, earlySignal = earlySignal,
     [23:32:30.240] label = label, ...)
     [23:32:30.240] if (!future$lazy)
     [23:32:30.240] future <- run(future)
     [23:32:30.240] invisible(future)
     [23:32:30.240] }), .cleanup = FALSE, .init = FALSE)
     [23:32:30.240] }
     [23:32:30.240] base::options(...future.oldOptions)
     [23:32:30.240] })
     [23:32:30.240] Sys.time
     [23:32:30.240] if (base::is.na(TRUE)) {
     [23:32:30.240] }
     [23:32:30.240] else {
     [23:32:30.240] base::sink(type = "output", split = FALSE)
     [23:32:30.240] if (TRUE) {
     [23:32:30.240] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [23:32:30.240] }
     [23:32:30.240] else {
     [23:32:30.240] ...future.result["stdout"] <- base::list(NULL)
     [23:32:30.240] }
     [23:32:30.240] base::close(...future.stdout)
     [23:32:30.240] ...future.stdout <- NULL
     [23:32:30.240] }
     [23:32:30.240] ...future.result$conditions <- ...future.conditions
     [23:32:30.240] ...future.result
     [23:32:30.240] }
     [23:32:30.243] requestCore(): workers = 2
     [23:32:30.264] MulticoreFuture started
     [23:32:30.279] plan(): Setting new future strategy stack:
     [23:32:30.280] List of future strategies:
     [23:32:30.280] 1. sequential:
     [23:32:30.280] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [23:32:30.280] - tweaked: FALSE
     [23:32:30.280] - call: NULL
     [23:32:30.282] plan(): nbrOfWorkers() = 1
     [23:32:30.285] plan(): Setting new future strategy stack:
     [23:32:30.286] List of future strategies:
     [23:32:30.286] 1. multicore:
     [23:32:30.286] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [23:32:30.286] - tweaked: FALSE
     [23:32:30.286] - call: plan(multicore)
     [23:32:30.288] plan(): nbrOfWorkers() = 2
     Number of OpenMP threads in 'MulticoreFuture' future: 3
     'future.fork.multithreading.enable' = TRUE ... DONE
     'future.fork.multithreading.enable' = FALSE ...
     [23:32:30.320] getGlobalsAndPackages() ...
     [23:32:30.321] Searching for globals...
     [23:32:30.322] - globals found: [1] '::'
     [23:32:30.323] Searching for globals ... DONE
     [23:32:30.323] Resolving globals: FALSE
     [23:32:30.324]
     [23:32:30.324]
     [23:32:30.325] getGlobalsAndPackages() ... DONE
     [23:32:30.325] - Evaluate future in single-threaded mode ...
     [23:32:30.326] supports_omp_threads() = TRUE
     [23:32:30.326] - Force single-threaded processing for OpenMP
     [23:32:30.326] - Evaluate future in single-threaded mode ... DONE
     [23:32:30.328] Packages needed by the future expression (n = 0): <none>
     [23:32:30.329] Packages needed by future strategies (n = 0): <none>
     [23:32:30.335] {
     [23:32:30.335] {
     [23:32:30.335] ...future.startTime <- base::Sys.time()
     [23:32:30.335] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [23:32:30.335] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [23:32:30.335] future.globals.method = NULL, future.globals.onMissing = NULL,
     [23:32:30.335] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [23:32:30.335] future.resolve.recursive = NULL, width = 80L)
     [23:32:30.335] {
     [23:32:30.335] {
     [23:32:30.335] {
     [23:32:30.335] has_future <- base::requireNamespace("future",
     [23:32:30.335] quietly = TRUE)
     [23:32:30.335] version <- if (has_future)
     [23:32:30.335] utils::packageVersion("future")
     [23:32:30.335] else NULL
     [23:32:30.335] if (!has_future || version < "1.8.0") {
     [23:32:30.335] info <- base::c(r_version = base::gsub("R version ",
     [23:32:30.335] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [23:32:30.335] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [23:32:30.335] os = base::paste(base::Sys.info()[base::c("sysname",
     [23:32:30.335] "release", "version")], collapse = " "),
     [23:32:30.335] hostname = base::Sys.info()[["nodename"]])
     [23:32:30.335] info <- base::sprintf("%s: %s", base::names(info),
     [23:32:30.335] info)
     [23:32:30.335] info <- base::paste(info, collapse = "; ")
     [23:32:30.335] if (!has_future) {
     [23:32:30.335] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [23:32:30.335] info)
     [23:32:30.335] }
     [23:32:30.335] else {
     [23:32:30.335] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [23:32:30.335] info, version)
     [23:32:30.335] }
     [23:32:30.335] base::stop(msg)
     [23:32:30.335] }
     [23:32:30.335] }
     [23:32:30.335] ...future.mc.cores.old <- base::getOption("mc.cores")
     [23:32:30.335] base::options(mc.cores = 1L)
     [23:32:30.335] }
     [23:32:30.335] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [23:32:30.335] }
     [23:32:30.335] }
     [23:32:30.335] if (base::is.na(TRUE)) {
     [23:32:30.335] }
     [23:32:30.335] else {
     [23:32:30.335] if (TRUE) {
     [23:32:30.335] ...future.stdout <- base::rawConnection(base::raw(0L),
     [23:32:30.335] open = "w")
     [23:32:30.335] }
     [23:32:30.335] else {
     [23:32:30.335] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [23:32:30.335] windows = "NUL", "/dev/null"), open = "w")
     [23:32:30.335] }
     [23:32:30.335] base::sink(...future.stdout, type = "output", split = FALSE)
     [23:32:30.335] base::on.exit(if (!base::is.null(...future.stdout)) {
     [23:32:30.335] base::sink(type = "output", split = FALSE)
     [23:32:30.335] base::close(...future.stdout)
     [23:32:30.335] }, add = TRUE)
     [23:32:30.335] }
     [23:32:30.335] ...future.frame <- base::sys.nframe()
     [23:32:30.335] ...future.conditions <- base::list()
     [23:32:30.335] ...future.rng <- base::globalenv()$.Random.seed
     [23:32:30.335] ...future.result <- base::tryCatch({
     [23:32:30.335] base::withCallingHandlers({
     [23:32:30.335] ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
     [23:32:30.335] future::FutureResult(value = ...future.value$value,
     [23:32:30.335] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [23:32:30.335] ...future.rng), started = ...future.startTime,
     [23:32:30.335] version = "1.8")
     [23:32:30.335] }, condition = base::local({
     [23:32:30.335] c <- base::c
     [23:32:30.335] inherits <- base::inherits
     [23:32:30.335] invokeRestart <- base::invokeRestart
     [23:32:30.335] length <- base::length
     [23:32:30.335] list <- base::list
     [23:32:30.335] seq.int <- base::seq.int
     [23:32:30.335] signalCondition <- base::signalCondition
     [23:32:30.335] sys.calls <- base::sys.calls
     [23:32:30.335] Sys.time <- base::Sys.time
     [23:32:30.335] `[[` <- base::`[[`
     [23:32:30.335] `+` <- base::`+`
     [23:32:30.335] `<<-` <- base::`<<-`
     [23:32:30.335] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [23:32:30.335] calls[seq.int(from = from + 12L, to = length(calls) -
     [23:32:30.335] 3L)]
     [23:32:30.335] }
     [23:32:30.335] function(cond) {
     [23:32:30.335] if (inherits(cond, "error")) {
     [23:32:30.335] ...future.conditions[[length(...future.conditions) +
     [23:32:30.335] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [23:32:30.335] cond$call), timestamp = Sys.time(), signaled = 0L)
     [23:32:30.335] signalCondition(cond)
     [23:32:30.335] }
     [23:32:30.335] else if (inherits(cond, "condition")) {
     [23:32:30.335] signal <- FALSE && inherits(cond, character(0))
     [23:32:30.335] ...future.conditions[[length(...future.conditions) +
     [23:32:30.335] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [23:32:30.335] if (!signal) {
     [23:32:30.335] muffleCondition <- function (cond)
     [23:32:30.335] {
     [23:32:30.335] inherits <- base::inherits
     [23:32:30.335] invokeRestart <- base::invokeRestart
     [23:32:30.335] muffled <- FALSE
     [23:32:30.335] if (inherits(cond, "message")) {
     [23:32:30.335] invokeRestart("muffleMessage")
     [23:32:30.335] muffled <- TRUE
     [23:32:30.335] }
     [23:32:30.335] else if (inherits(cond, "warning")) {
     [23:32:30.335] invokeRestart("muffleWarning")
     [23:32:30.335] muffled <- TRUE
     [23:32:30.335] }
     [23:32:30.335] else if (inherits(cond, "condition")) {
     [23:32:30.335] computeRestarts <- base::computeRestarts
     [23:32:30.335] grepl <- base::grepl
     [23:32:30.335] is.null <- base::is.null
     [23:32:30.335] restarts <- computeRestarts(cond)
     [23:32:30.335] for (restart in restarts) {
     [23:32:30.335] name <- restart$name
     [23:32:30.335] if (is.null(name))
     [23:32:30.335] next
     [23:32:30.335] if (!grepl("^muffle", name))
     [23:32:30.335] next
     [23:32:30.335] invokeRestart(restart)
     [23:32:30.335] muffled <- TRUE
     [23:32:30.335] break
     [23:32:30.335] }
     [23:32:30.335] }
     [23:32:30.335] invisible(muffled)
     [23:32:30.335] }
     [23:32:30.335] muffleCondition(cond)
     [23:32:30.335] }
     [23:32:30.335] }
     [23:32:30.335] }
     [23:32:30.335] }))
     [23:32:30.335] }, error = function(ex) {
     [23:32:30.335] base::structure(base::list(value = NULL, visible = NULL,
     [23:32:30.335] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [23:32:30.335] ...future.rng), version = "1.8"), class = "FutureResult")
     [23:32:30.335] }, finally = {
     [23:32:30.335] {
     [23:32:30.335] {
     [23:32:30.335] base::options(mc.cores = ...future.mc.cores.old)
     [23:32:30.335] }
     [23:32:30.335] future::plan(list(function (expr, envir = parent.frame(),
     [23:32:30.335] substitute = TRUE, lazy = FALSE, seed = NULL,
     [23:32:30.335] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [23:32:30.335] earlySignal = FALSE, label = NULL, ...)
     [23:32:30.335] {
     [23:32:30.335] if (substitute)
     [23:32:30.335] expr <- substitute(expr)
     [23:32:30.335] if (is.function(workers))
     [23:32:30.335] workers <- workers()
     [23:32:30.335] workers <- as.integer(workers)
     [23:32:30.335] stop_if_not(is.finite(workers), workers >= 1L)
     [23:32:30.335] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [23:32:30.335] return(sequential(expr, envir = envir, substitute = FALSE,
     [23:32:30.335] lazy = lazy, seed = seed, globals = globals,
     [23:32:30.335] local = TRUE, label = label, ...))
     [23:32:30.335] }
     [23:32:30.335] oopts <- options(mc.cores = workers)
     [23:32:30.335] on.exit(options(oopts))
     [23:32:30.335] future <- MulticoreFuture(expr = expr, envir = envir,
     [23:32:30.335] substitute = FALSE, lazy = lazy, seed = seed,
     [23:32:30.335] globals = globals, workers = workers, earlySignal = earlySignal,
     [23:32:30.335] label = label, ...)
     [23:32:30.335] if (!future$lazy)
     [23:32:30.335] future <- run(future)
     [23:32:30.335] invisible(future)
     [23:32:30.335] }), .cleanup = FALSE, .init = FALSE)
     [23:32:30.335] }
     [23:32:30.335] base::options(...future.oldOptions)
     [23:32:30.335] })
     [23:32:30.335] Sys.time
     [23:32:30.335] if (base::is.na(TRUE)) {
     [23:32:30.335] }
     [23:32:30.335] else {
     [23:32:30.335] base::sink(type = "output", split = FALSE)
     [23:32:30.335] if (TRUE) {
     [23:32:30.335] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [23:32:30.335] }
     [23:32:30.335] else {
     [23:32:30.335] ...future.result["stdout"] <- base::list(NULL)
     [23:32:30.335] }
     [23:32:30.335] base::close(...future.stdout)
     [23:32:30.335] ...future.stdout <- NULL
     [23:32:30.335] }
     [23:32:30.335] ...future.result$conditions <- ...future.conditions
     [23:32:30.335] ...future.result
     [23:32:30.335] }
     [23:32:30.338] requestCore(): workers = 2
     [23:32:30.357] MulticoreFuture started
     [23:32:30.369] plan(): Setting new future strategy stack:
     [23:32:30.370] List of future strategies:
     [23:32:30.370] 1. sequential:
     [23:32:30.370] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [23:32:30.370] - tweaked: FALSE
     [23:32:30.370] - call: NULL
     [23:32:30.413] plan(): nbrOfWorkers() = 1
     [23:32:30.417] plan(): Setting new future strategy stack:
     [23:32:30.418] List of future strategies:
     [23:32:30.418] 1. multicore:
     [23:32:30.418] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [23:32:30.418] - tweaked: FALSE
     [23:32:30.418] - call: plan(multicore)
     [23:32:30.420] plan(): nbrOfWorkers() = 2
     Number of OpenMP threads in 'MulticoreFuture' future: 3
     Error: !enable && nthreads == 1L is not TRUE
     Execution halted
Flavor: r-devel-linux-x86_64-debian-clang

Version: 1.16.0
Check: tests
Result: ERROR
     Running ‘000.sessionDetails.R’ [9s/11s]
     Running ‘ClusterRegistry.R’ [4s/66s]
     Running ‘Future-class.R’ [2s/22s]
     Running ‘FutureError.R’
     Running ‘FutureGlobals.R’
     Running ‘FutureRegistry.R’
     Running ‘as.cluster.R’ [2s/23s]
     Running ‘availableCores.R’
     Running ‘availableWorkers.R’
     Running ‘backtrace.R’
     Running ‘cluster-missing-future-pkg.R’
     Running ‘cluster.R’ [9s/141s]
     Running ‘constant.R’
     Running ‘demo.R’ [12s/34s]
     Running ‘dotdotdot.R’ [2s/25s]
     Running ‘early-signaling.R’ [3s/46s]
     Running ‘future,labels.R’
     Running ‘future.R’
     Running ‘futureAssign.R’ [3s/23s]
     Running ‘futureAssign_OP.R’ [4s/25s]
     Running ‘futureAssign_OP_with_environment.R’
     Running ‘futureAssign_OP_with_listenv.R’
     Running ‘futureCall.R’ [5s/39s]
     Running ‘futureOf.R’
     Running ‘futureOf_with_environment.R’
     Running ‘futureOf_with_listenv.R’
     Running ‘futures.R’ [23s/182s]
     Running ‘globals,NSE.R’
     Running ‘globals,formulas.R’ [5s/27s]
     Running ‘globals,manual.R’
     Running ‘globals,resolve.R’ [2s/23s]
     Running ‘globals,subassignment.R’ [4s/25s]
     Running ‘globals,toolarge.R’ [2s/22s]
     Running ‘globals,tricky.R’ [9s/33s]
     Running ‘globals,tricky_recursive.R’
     Running ‘globalsOf,tweaks.R’
     Running ‘immediateCondition.R’
     Running ‘invalid-owner.R’ [2s/23s]
     Running ‘makeClusterPSOCK.R’ [1s/12s]
     Running ‘mandelbrot.R’
     Running ‘mpi.R’
     Running ‘multicore,multithreading.R’
     Running ‘multicore.R’
     Running ‘multiprocess.R’
     Running ‘multisession.R’ [6s/68s]
     Running ‘nbrOfWorkers.R’ [6s/89s]
     Running ‘nested_futures,mc.cores.R’ [7s/152s]
     Running ‘nested_futures.R’
     Running ‘non-exportable,connections.R’ [2s/23s]
     Running ‘objectSize.R’
     Running ‘plan.R’ [9s/23s]
     Running ‘relaying.R’
     Running ‘remote.R’ [2s/23s]
     Running ‘requestCore.R’
     Running ‘requestNode.R’ [2s/36s]
     Running ‘reserved-keyword-functions.R’
     Running ‘resolve.R’
     Running ‘resolved-non-blocking-test.R’ [4s/79s]
     Running ‘rng.R’ [14s/40s]
     Running ‘sequential.R’
     Running ‘sessionDetails.R’
     Running ‘startup.R’ [3s/45s]
     Running ‘stdout.R’ [3s/23s]
     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:15:08.988] plan(): Setting new future strategy stack:
     [16:15:08.990] List of future strategies:
     [16:15:08.990] 1. sequential:
     [16:15:08.990] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [16:15:08.990] - tweaked: FALSE
     [16:15:08.990] - call: future::plan("sequential")
     [16:15:08.992] plan(): nbrOfWorkers() = 1
     > library("listenv")
     > plan(multicore)
     [16:15:09.054] plan(): Setting new future strategy stack:
     [16:15:09.054] List of future strategies:
     [16:15:09.054] 1. multicore:
     [16:15:09.054] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [16:15:09.054] - tweaked: FALSE
     [16:15:09.054] - call: plan(multicore)
     [16:15:09.131] 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:15:09.237] 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:15:09.240] supports_omp_threads() = TRUE
     'future.fork.multithreading.enable' = TRUE ...
     [16:15:09.279] getGlobalsAndPackages() ...
     [16:15:09.279] Searching for globals...
     [16:15:09.296] - globals found: [1] '::'
     [16:15:09.297] Searching for globals ... DONE
     [16:15:09.297] Resolving globals: FALSE
     [16:15:09.298]
     [16:15:09.299]
     [16:15:09.299] getGlobalsAndPackages() ... DONE
     [16:15:09.317] Packages needed by the future expression (n = 0): <none>
     [16:15:09.318] Packages needed by future strategies (n = 0): <none>
     [16:15:09.325] {
     [16:15:09.325] {
     [16:15:09.325] ...future.startTime <- base::Sys.time()
     [16:15:09.325] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [16:15:09.325] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [16:15:09.325] future.globals.method = NULL, future.globals.onMissing = NULL,
     [16:15:09.325] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [16:15:09.325] future.resolve.recursive = NULL, width = 80L)
     [16:15:09.325] {
     [16:15:09.325] {
     [16:15:09.325] {
     [16:15:09.325] has_future <- base::requireNamespace("future",
     [16:15:09.325] quietly = TRUE)
     [16:15:09.325] version <- if (has_future)
     [16:15:09.325] utils::packageVersion("future")
     [16:15:09.325] else NULL
     [16:15:09.325] if (!has_future || version < "1.8.0") {
     [16:15:09.325] info <- base::c(r_version = base::gsub("R version ",
     [16:15:09.325] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [16:15:09.325] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [16:15:09.325] os = base::paste(base::Sys.info()[base::c("sysname",
     [16:15:09.325] "release", "version")], collapse = " "),
     [16:15:09.325] hostname = base::Sys.info()[["nodename"]])
     [16:15:09.325] info <- base::sprintf("%s: %s", base::names(info),
     [16:15:09.325] info)
     [16:15:09.325] info <- base::paste(info, collapse = "; ")
     [16:15:09.325] if (!has_future) {
     [16:15:09.325] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [16:15:09.325] info)
     [16:15:09.325] }
     [16:15:09.325] else {
     [16:15:09.325] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [16:15:09.325] info, version)
     [16:15:09.325] }
     [16:15:09.325] base::stop(msg)
     [16:15:09.325] }
     [16:15:09.325] }
     [16:15:09.325] ...future.mc.cores.old <- base::getOption("mc.cores")
     [16:15:09.325] base::options(mc.cores = 1L)
     [16:15:09.325] }
     [16:15:09.325] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [16:15:09.325] }
     [16:15:09.325] }
     [16:15:09.325] if (base::is.na(TRUE)) {
     [16:15:09.325] }
     [16:15:09.325] else {
     [16:15:09.325] if (TRUE) {
     [16:15:09.325] ...future.stdout <- base::rawConnection(base::raw(0L),
     [16:15:09.325] open = "w")
     [16:15:09.325] }
     [16:15:09.325] else {
     [16:15:09.325] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [16:15:09.325] windows = "NUL", "/dev/null"), open = "w")
     [16:15:09.325] }
     [16:15:09.325] base::sink(...future.stdout, type = "output", split = FALSE)
     [16:15:09.325] base::on.exit(if (!base::is.null(...future.stdout)) {
     [16:15:09.325] base::sink(type = "output", split = FALSE)
     [16:15:09.325] base::close(...future.stdout)
     [16:15:09.325] }, add = TRUE)
     [16:15:09.325] }
     [16:15:09.325] ...future.frame <- base::sys.nframe()
     [16:15:09.325] ...future.conditions <- base::list()
     [16:15:09.325] ...future.rng <- base::globalenv()$.Random.seed
     [16:15:09.325] ...future.result <- base::tryCatch({
     [16:15:09.325] base::withCallingHandlers({
     [16:15:09.325] ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
     [16:15:09.325] future::FutureResult(value = ...future.value$value,
     [16:15:09.325] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [16:15:09.325] ...future.rng), started = ...future.startTime,
     [16:15:09.325] version = "1.8")
     [16:15:09.325] }, condition = base::local({
     [16:15:09.325] c <- base::c
     [16:15:09.325] inherits <- base::inherits
     [16:15:09.325] invokeRestart <- base::invokeRestart
     [16:15:09.325] length <- base::length
     [16:15:09.325] list <- base::list
     [16:15:09.325] seq.int <- base::seq.int
     [16:15:09.325] signalCondition <- base::signalCondition
     [16:15:09.325] sys.calls <- base::sys.calls
     [16:15:09.325] Sys.time <- base::Sys.time
     [16:15:09.325] `[[` <- base::`[[`
     [16:15:09.325] `+` <- base::`+`
     [16:15:09.325] `<<-` <- base::`<<-`
     [16:15:09.325] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [16:15:09.325] calls[seq.int(from = from + 12L, to = length(calls) -
     [16:15:09.325] 3L)]
     [16:15:09.325] }
     [16:15:09.325] function(cond) {
     [16:15:09.325] if (inherits(cond, "error")) {
     [16:15:09.325] ...future.conditions[[length(...future.conditions) +
     [16:15:09.325] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [16:15:09.325] cond$call), timestamp = Sys.time(), signaled = 0L)
     [16:15:09.325] signalCondition(cond)
     [16:15:09.325] }
     [16:15:09.325] else if (inherits(cond, "condition")) {
     [16:15:09.325] signal <- FALSE && inherits(cond, character(0))
     [16:15:09.325] ...future.conditions[[length(...future.conditions) +
     [16:15:09.325] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [16:15:09.325] if (!signal) {
     [16:15:09.325] muffleCondition <- function (cond)
     [16:15:09.325] {
     [16:15:09.325] inherits <- base::inherits
     [16:15:09.325] invokeRestart <- base::invokeRestart
     [16:15:09.325] muffled <- FALSE
     [16:15:09.325] if (inherits(cond, "message")) {
     [16:15:09.325] invokeRestart("muffleMessage")
     [16:15:09.325] muffled <- TRUE
     [16:15:09.325] }
     [16:15:09.325] else if (inherits(cond, "warning")) {
     [16:15:09.325] invokeRestart("muffleWarning")
     [16:15:09.325] muffled <- TRUE
     [16:15:09.325] }
     [16:15:09.325] else if (inherits(cond, "condition")) {
     [16:15:09.325] computeRestarts <- base::computeRestarts
     [16:15:09.325] grepl <- base::grepl
     [16:15:09.325] is.null <- base::is.null
     [16:15:09.325] restarts <- computeRestarts(cond)
     [16:15:09.325] for (restart in restarts) {
     [16:15:09.325] name <- restart$name
     [16:15:09.325] if (is.null(name))
     [16:15:09.325] next
     [16:15:09.325] if (!grepl("^muffle", name))
     [16:15:09.325] next
     [16:15:09.325] invokeRestart(restart)
     [16:15:09.325] muffled <- TRUE
     [16:15:09.325] break
     [16:15:09.325] }
     [16:15:09.325] }
     [16:15:09.325] invisible(muffled)
     [16:15:09.325] }
     [16:15:09.325] muffleCondition(cond)
     [16:15:09.325] }
     [16:15:09.325] }
     [16:15:09.325] }
     [16:15:09.325] }))
     [16:15:09.325] }, error = function(ex) {
     [16:15:09.325] base::structure(base::list(value = NULL, visible = NULL,
     [16:15:09.325] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [16:15:09.325] ...future.rng), version = "1.8"), class = "FutureResult")
     [16:15:09.325] }, finally = {
     [16:15:09.325] {
     [16:15:09.325] {
     [16:15:09.325] base::options(mc.cores = ...future.mc.cores.old)
     [16:15:09.325] }
     [16:15:09.325] future::plan(list(function (expr, envir = parent.frame(),
     [16:15:09.325] substitute = TRUE, lazy = FALSE, seed = NULL,
     [16:15:09.325] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [16:15:09.325] earlySignal = FALSE, label = NULL, ...)
     [16:15:09.325] {
     [16:15:09.325] if (substitute)
     [16:15:09.325] expr <- substitute(expr)
     [16:15:09.325] if (is.function(workers))
     [16:15:09.325] workers <- workers()
     [16:15:09.325] workers <- as.integer(workers)
     [16:15:09.325] stop_if_not(is.finite(workers), workers >= 1L)
     [16:15:09.325] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [16:15:09.325] return(sequential(expr, envir = envir, substitute = FALSE,
     [16:15:09.325] lazy = lazy, seed = seed, globals = globals,
     [16:15:09.325] local = TRUE, label = label, ...))
     [16:15:09.325] }
     [16:15:09.325] oopts <- options(mc.cores = workers)
     [16:15:09.325] on.exit(options(oopts))
     [16:15:09.325] future <- MulticoreFuture(expr = expr, envir = envir,
     [16:15:09.325] substitute = FALSE, lazy = lazy, seed = seed,
     [16:15:09.325] globals = globals, workers = workers, earlySignal = earlySignal,
     [16:15:09.325] label = label, ...)
     [16:15:09.325] if (!future$lazy)
     [16:15:09.325] future <- run(future)
     [16:15:09.325] invisible(future)
     [16:15:09.325] }), .cleanup = FALSE, .init = FALSE)
     [16:15:09.325] }
     [16:15:09.325] base::options(...future.oldOptions)
     [16:15:09.325] })
     [16:15:09.325] Sys.time
     [16:15:09.325] if (base::is.na(TRUE)) {
     [16:15:09.325] }
     [16:15:09.325] else {
     [16:15:09.325] base::sink(type = "output", split = FALSE)
     [16:15:09.325] if (TRUE) {
     [16:15:09.325] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [16:15:09.325] }
     [16:15:09.325] else {
     [16:15:09.325] ...future.result["stdout"] <- base::list(NULL)
     [16:15:09.325] }
     [16:15:09.325] base::close(...future.stdout)
     [16:15:09.325] ...future.stdout <- NULL
     [16:15:09.325] }
     [16:15:09.325] ...future.result$conditions <- ...future.conditions
     [16:15:09.325] ...future.result
     [16:15:09.325] }
     [16:15:09.355] requestCore(): workers = 2
     [16:15:09.361] MulticoreFuture started
     [16:15:09.374] plan(): Setting new future strategy stack:
     [16:15:09.375] List of future strategies:
     [16:15:09.375] 1. sequential:
     [16:15:09.375] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [16:15:09.375] - tweaked: FALSE
     [16:15:09.375] - call: NULL
     [16:15:09.377] plan(): nbrOfWorkers() = 1
     [16:15:09.382] plan(): Setting new future strategy stack:
     [16:15:09.383] List of future strategies:
     [16:15:09.383] 1. multicore:
     [16:15:09.383] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [16:15:09.383] - tweaked: FALSE
     [16:15:09.383] - call: plan(multicore)
     [16:15:09.386] plan(): nbrOfWorkers() = 2
     Number of OpenMP threads in 'MulticoreFuture' future: 24
     'future.fork.multithreading.enable' = TRUE ... DONE
     'future.fork.multithreading.enable' = FALSE ...
     [16:15:09.406] getGlobalsAndPackages() ...
     [16:15:09.406] Searching for globals...
     [16:15:09.408] - globals found: [1] '::'
     [16:15:09.409] Searching for globals ... DONE
     [16:15:09.409] Resolving globals: FALSE
     [16:15:09.410]
     [16:15:09.411]
     [16:15:09.411] getGlobalsAndPackages() ... DONE
     [16:15:09.412] - Evaluate future in single-threaded mode ...
     [16:15:09.412] supports_omp_threads() = TRUE
     [16:15:09.413] - Force single-threaded processing for OpenMP
     [16:15:09.413] - Evaluate future in single-threaded mode ... DONE
     [16:15:09.416] Packages needed by the future expression (n = 0): <none>
     [16:15:09.417] Packages needed by future strategies (n = 0): <none>
     [16:15:09.424] {
     [16:15:09.424] {
     [16:15:09.424] ...future.startTime <- base::Sys.time()
     [16:15:09.424] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [16:15:09.424] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [16:15:09.424] future.globals.method = NULL, future.globals.onMissing = NULL,
     [16:15:09.424] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [16:15:09.424] future.resolve.recursive = NULL, width = 80L)
     [16:15:09.424] {
     [16:15:09.424] {
     [16:15:09.424] {
     [16:15:09.424] has_future <- base::requireNamespace("future",
     [16:15:09.424] quietly = TRUE)
     [16:15:09.424] version <- if (has_future)
     [16:15:09.424] utils::packageVersion("future")
     [16:15:09.424] else NULL
     [16:15:09.424] if (!has_future || version < "1.8.0") {
     [16:15:09.424] info <- base::c(r_version = base::gsub("R version ",
     [16:15:09.424] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [16:15:09.424] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [16:15:09.424] os = base::paste(base::Sys.info()[base::c("sysname",
     [16:15:09.424] "release", "version")], collapse = " "),
     [16:15:09.424] hostname = base::Sys.info()[["nodename"]])
     [16:15:09.424] info <- base::sprintf("%s: %s", base::names(info),
     [16:15:09.424] info)
     [16:15:09.424] info <- base::paste(info, collapse = "; ")
     [16:15:09.424] if (!has_future) {
     [16:15:09.424] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [16:15:09.424] info)
     [16:15:09.424] }
     [16:15:09.424] else {
     [16:15:09.424] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [16:15:09.424] info, version)
     [16:15:09.424] }
     [16:15:09.424] base::stop(msg)
     [16:15:09.424] }
     [16:15:09.424] }
     [16:15:09.424] ...future.mc.cores.old <- base::getOption("mc.cores")
     [16:15:09.424] base::options(mc.cores = 1L)
     [16:15:09.424] }
     [16:15:09.424] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [16:15:09.424] }
     [16:15:09.424] }
     [16:15:09.424] if (base::is.na(TRUE)) {
     [16:15:09.424] }
     [16:15:09.424] else {
     [16:15:09.424] if (TRUE) {
     [16:15:09.424] ...future.stdout <- base::rawConnection(base::raw(0L),
     [16:15:09.424] open = "w")
     [16:15:09.424] }
     [16:15:09.424] else {
     [16:15:09.424] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [16:15:09.424] windows = "NUL", "/dev/null"), open = "w")
     [16:15:09.424] }
     [16:15:09.424] base::sink(...future.stdout, type = "output", split = FALSE)
     [16:15:09.424] base::on.exit(if (!base::is.null(...future.stdout)) {
     [16:15:09.424] base::sink(type = "output", split = FALSE)
     [16:15:09.424] base::close(...future.stdout)
     [16:15:09.424] }, add = TRUE)
     [16:15:09.424] }
     [16:15:09.424] ...future.frame <- base::sys.nframe()
     [16:15:09.424] ...future.conditions <- base::list()
     [16:15:09.424] ...future.rng <- base::globalenv()$.Random.seed
     [16:15:09.424] ...future.result <- base::tryCatch({
     [16:15:09.424] base::withCallingHandlers({
     [16:15:09.424] ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
     [16:15:09.424] future::FutureResult(value = ...future.value$value,
     [16:15:09.424] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [16:15:09.424] ...future.rng), started = ...future.startTime,
     [16:15:09.424] version = "1.8")
     [16:15:09.424] }, condition = base::local({
     [16:15:09.424] c <- base::c
     [16:15:09.424] inherits <- base::inherits
     [16:15:09.424] invokeRestart <- base::invokeRestart
     [16:15:09.424] length <- base::length
     [16:15:09.424] list <- base::list
     [16:15:09.424] seq.int <- base::seq.int
     [16:15:09.424] signalCondition <- base::signalCondition
     [16:15:09.424] sys.calls <- base::sys.calls
     [16:15:09.424] Sys.time <- base::Sys.time
     [16:15:09.424] `[[` <- base::`[[`
     [16:15:09.424] `+` <- base::`+`
     [16:15:09.424] `<<-` <- base::`<<-`
     [16:15:09.424] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [16:15:09.424] calls[seq.int(from = from + 12L, to = length(calls) -
     [16:15:09.424] 3L)]
     [16:15:09.424] }
     [16:15:09.424] function(cond) {
     [16:15:09.424] if (inherits(cond, "error")) {
     [16:15:09.424] ...future.conditions[[length(...future.conditions) +
     [16:15:09.424] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [16:15:09.424] cond$call), timestamp = Sys.time(), signaled = 0L)
     [16:15:09.424] signalCondition(cond)
     [16:15:09.424] }
     [16:15:09.424] else if (inherits(cond, "condition")) {
     [16:15:09.424] signal <- FALSE && inherits(cond, character(0))
     [16:15:09.424] ...future.conditions[[length(...future.conditions) +
     [16:15:09.424] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [16:15:09.424] if (!signal) {
     [16:15:09.424] muffleCondition <- function (cond)
     [16:15:09.424] {
     [16:15:09.424] inherits <- base::inherits
     [16:15:09.424] invokeRestart <- base::invokeRestart
     [16:15:09.424] muffled <- FALSE
     [16:15:09.424] if (inherits(cond, "message")) {
     [16:15:09.424] invokeRestart("muffleMessage")
     [16:15:09.424] muffled <- TRUE
     [16:15:09.424] }
     [16:15:09.424] else if (inherits(cond, "warning")) {
     [16:15:09.424] invokeRestart("muffleWarning")
     [16:15:09.424] muffled <- TRUE
     [16:15:09.424] }
     [16:15:09.424] else if (inherits(cond, "condition")) {
     [16:15:09.424] computeRestarts <- base::computeRestarts
     [16:15:09.424] grepl <- base::grepl
     [16:15:09.424] is.null <- base::is.null
     [16:15:09.424] restarts <- computeRestarts(cond)
     [16:15:09.424] for (restart in restarts) {
     [16:15:09.424] name <- restart$name
     [16:15:09.424] if (is.null(name))
     [16:15:09.424] next
     [16:15:09.424] if (!grepl("^muffle", name))
     [16:15:09.424] next
     [16:15:09.424] invokeRestart(restart)
     [16:15:09.424] muffled <- TRUE
     [16:15:09.424] break
     [16:15:09.424] }
     [16:15:09.424] }
     [16:15:09.424] invisible(muffled)
     [16:15:09.424] }
     [16:15:09.424] muffleCondition(cond)
     [16:15:09.424] }
     [16:15:09.424] }
     [16:15:09.424] }
     [16:15:09.424] }))
     [16:15:09.424] }, error = function(ex) {
     [16:15:09.424] base::structure(base::list(value = NULL, visible = NULL,
     [16:15:09.424] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [16:15:09.424] ...future.rng), version = "1.8"), class = "FutureResult")
     [16:15:09.424] }, finally = {
     [16:15:09.424] {
     [16:15:09.424] {
     [16:15:09.424] base::options(mc.cores = ...future.mc.cores.old)
     [16:15:09.424] }
     [16:15:09.424] future::plan(list(function (expr, envir = parent.frame(),
     [16:15:09.424] substitute = TRUE, lazy = FALSE, seed = NULL,
     [16:15:09.424] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [16:15:09.424] earlySignal = FALSE, label = NULL, ...)
     [16:15:09.424] {
     [16:15:09.424] if (substitute)
     [16:15:09.424] expr <- substitute(expr)
     [16:15:09.424] if (is.function(workers))
     [16:15:09.424] workers <- workers()
     [16:15:09.424] workers <- as.integer(workers)
     [16:15:09.424] stop_if_not(is.finite(workers), workers >= 1L)
     [16:15:09.424] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [16:15:09.424] return(sequential(expr, envir = envir, substitute = FALSE,
     [16:15:09.424] lazy = lazy, seed = seed, globals = globals,
     [16:15:09.424] local = TRUE, label = label, ...))
     [16:15:09.424] }
     [16:15:09.424] oopts <- options(mc.cores = workers)
     [16:15:09.424] on.exit(options(oopts))
     [16:15:09.424] future <- MulticoreFuture(expr = expr, envir = envir,
     [16:15:09.424] substitute = FALSE, lazy = lazy, seed = seed,
     [16:15:09.424] globals = globals, workers = workers, earlySignal = earlySignal,
     [16:15:09.424] label = label, ...)
     [16:15:09.424] if (!future$lazy)
     [16:15:09.424] future <- run(future)
     [16:15:09.424] invisible(future)
     [16:15:09.424] }), .cleanup = FALSE, .init = FALSE)
     [16:15:09.424] }
     [16:15:09.424] base::options(...future.oldOptions)
     [16:15:09.424] })
     [16:15:09.424] Sys.time
     [16:15:09.424] if (base::is.na(TRUE)) {
     [16:15:09.424] }
     [16:15:09.424] else {
     [16:15:09.424] base::sink(type = "output", split = FALSE)
     [16:15:09.424] if (TRUE) {
     [16:15:09.424] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [16:15:09.424] }
     [16:15:09.424] else {
     [16:15:09.424] ...future.result["stdout"] <- base::list(NULL)
     [16:15:09.424] }
     [16:15:09.424] base::close(...future.stdout)
     [16:15:09.424] ...future.stdout <- NULL
     [16:15:09.424] }
     [16:15:09.424] ...future.result$conditions <- ...future.conditions
     [16:15:09.424] ...future.result
     [16:15:09.424] }
     [16:15:09.430] requestCore(): workers = 2
     [16:15:09.434] MulticoreFuture started
     [16:15:09.446] plan(): Setting new future strategy stack:
     [16:15:09.447] List of future strategies:
     [16:15:09.447] 1. sequential:
     [16:15:09.447] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [16:15:09.447] - tweaked: FALSE
     [16:15:09.447] - call: NULL
     [16:15:09.468] plan(): nbrOfWorkers() = 1
     [16:15:09.472] plan(): Setting new future strategy stack:
     [16:15:09.473] List of future strategies:
     [16:15:09.473] 1. multicore:
     [16:15:09.473] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [16:15:09.473] - tweaked: FALSE
     [16:15:09.473] - call: plan(multicore)
     [16:15:09.476] plan(): nbrOfWorkers() = 2
     Number of OpenMP threads in 'MulticoreFuture' future: 24
     Error: !enable && nthreads == 1L is not TRUE
     Execution halted
Flavor: r-devel-linux-x86_64-fedora-clang