CRAN Package Check Results for Package future

Last updated on 2020-01-27 00:48:03 CET.

Flavor Version Tinstall Tcheck Ttotal Status Flags
r-devel-linux-x86_64-debian-clang 1.16.0 8.95 228.34 237.29 ERROR
r-devel-linux-x86_64-debian-gcc 1.16.0 8.20 182.36 190.56 OK
r-devel-linux-x86_64-fedora-clang 1.16.0 295.38 ERROR
r-devel-linux-x86_64-fedora-gcc 1.16.0 292.02 OK
r-devel-windows-ix86+x86_64 1.16.0 23.00 477.00 500.00 OK
r-devel-windows-ix86+x86_64-gcc8 1.16.0 23.00 463.00 486.00 OK
r-patched-linux-x86_64 1.16.0 7.22 213.31 220.53 OK
r-patched-solaris-x86 1.16.0 104.40 OK --no-tests
r-release-linux-x86_64 1.16.0 7.97 210.93 218.90 OK
r-release-windows-ix86+x86_64 1.16.0 13.00 329.00 342.00 OK
r-release-osx-x86_64 1.16.0 OK
r-oldrel-windows-ix86+x86_64 1.16.0 12.00 317.00 329.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/54s]
     Running 'Future-class.R' [2s/19s]
     Running 'FutureError.R' [1s/1s]
     Running 'FutureGlobals.R' [1s/1s]
     Running 'FutureRegistry.R' [1s/1s]
     Running 'as.cluster.R' [1s/18s]
     Running 'availableCores.R' [1s/1s]
     Running 'availableWorkers.R' [1s/1s]
     Running 'backtrace.R' [1s/1s]
     Running 'cluster-missing-future-pkg.R' [1s/3s]
     Running 'cluster.R' [7s/120s]
     Running 'constant.R' [1s/1s]
     Running 'demo.R' [10s/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/20s]
     Running 'futureAssign_OP.R' [3s/22s]
     Running 'futureAssign_OP_with_environment.R' [1s/1s]
     Running 'futureAssign_OP_with_listenv.R' [1s/1s]
     Running 'futureCall.R' [4s/31s]
     Running 'futureOf.R' [1s/1s]
     Running 'futureOf_with_environment.R' [1s/1s]
     Running 'futureOf_with_listenv.R' [1s/1s]
     Running 'futures.R' [19s/148s]
     Running 'globals,NSE.R' [1s/1s]
     Running 'globals,formulas.R' [4s/22s]
     Running 'globals,manual.R' [2s/2s]
     Running 'globals,resolve.R' [2s/19s]
     Running 'globals,subassignment.R' [3s/21s]
     Running 'globals,toolarge.R' [1s/18s]
     Running 'globals,tricky.R' [7s/29s]
     Running 'globals,tricky_recursive.R' [1s/1s]
     Running 'globalsOf,tweaks.R' [1s/1s]
     Running 'immediateCondition.R' [1s/1s]
     Running 'invalid-owner.R' [2s/18s]
     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/1s]
     Running 'multiprocess.R' [2s/2s]
     Running 'multisession.R' [5s/57s]
     Running 'nbrOfWorkers.R' [5s/72s]
     Running 'nested_futures,mc.cores.R' [6s/122s]
     Running 'nested_futures.R' [1s/1s]
     Running 'non-exportable,connections.R' [1s/19s]
     Running 'objectSize.R' [1s/1s]
     Running 'plan.R' [6s/15s]
     Running 'relaying.R' [1s/3s]
     Running 'remote.R' [1s/18s]
     Running 'requestCore.R' [1s/3s]
     Running 'requestNode.R' [2s/33s]
     Running 'reserved-keyword-functions.R' [1s/1s]
     Running 'resolve.R' [2s/4s]
     Running 'resolved-non-blocking-test.R' [3s/71s]
     Running 'rng.R' [12s/35s]
     Running 'sequential.R' [1s/1s]
     Running 'sessionDetails.R' [1s/1s]
     Running 'startup.R' [2s/37s]
     Running 'stdout.R' [2s/20s]
     Running 'transparent.R' [1s/1s]
     Running 'tweak.R' [1s/1s]
     Running 'utils.R' [8s/9s]
     Running 'uuid.R' [1s/1s]
     Running 'whichIndex.R' [1s/1s]
    Running the tests in 'tests/multicore,multithreading.R' failed.
    Complete output:
     > source("incl/start.R")
     [23:22:04.491] plan(): Setting new future strategy stack:
     [23:22:04.494] List of future strategies:
     [23:22:04.494] 1. sequential:
     [23:22:04.494] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [23:22:04.494] - tweaked: FALSE
     [23:22:04.494] - call: future::plan("sequential")
     [23:22:04.496] plan(): nbrOfWorkers() = 1
     > library("listenv")
     > plan(multicore)
     [23:22:04.538] plan(): Setting new future strategy stack:
     [23:22:04.538] List of future strategies:
     [23:22:04.538] 1. multicore:
     [23:22:04.538] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [23:22:04.538] - tweaked: FALSE
     [23:22:04.538] - call: plan(multicore)
     [23:22:04.577] 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:22:04.754] 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:22:04.757] supports_omp_threads() = TRUE
     'future.fork.multithreading.enable' = TRUE ...
     [23:22:04.825] getGlobalsAndPackages() ...
     [23:22:04.825] Searching for globals...
     [23:22:04.852] - globals found: [1] '::'
     [23:22:04.853] Searching for globals ... DONE
     [23:22:04.853] Resolving globals: FALSE
     [23:22:04.855]
     [23:22:04.855]
     [23:22:04.855] getGlobalsAndPackages() ... DONE
     [23:22:04.861] Packages needed by the future expression (n = 0): <none>
     [23:22:04.861] Packages needed by future strategies (n = 0): <none>
     [23:22:04.869] {
     [23:22:04.869] {
     [23:22:04.869] ...future.startTime <- base::Sys.time()
     [23:22:04.869] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [23:22:04.869] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [23:22:04.869] future.globals.method = NULL, future.globals.onMissing = NULL,
     [23:22:04.869] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [23:22:04.869] future.resolve.recursive = NULL, width = 80L)
     [23:22:04.869] {
     [23:22:04.869] {
     [23:22:04.869] {
     [23:22:04.869] has_future <- base::requireNamespace("future",
     [23:22:04.869] quietly = TRUE)
     [23:22:04.869] version <- if (has_future)
     [23:22:04.869] utils::packageVersion("future")
     [23:22:04.869] else NULL
     [23:22:04.869] if (!has_future || version < "1.8.0") {
     [23:22:04.869] info <- base::c(r_version = base::gsub("R version ",
     [23:22:04.869] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [23:22:04.869] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [23:22:04.869] os = base::paste(base::Sys.info()[base::c("sysname",
     [23:22:04.869] "release", "version")], collapse = " "),
     [23:22:04.869] hostname = base::Sys.info()[["nodename"]])
     [23:22:04.869] info <- base::sprintf("%s: %s", base::names(info),
     [23:22:04.869] info)
     [23:22:04.869] info <- base::paste(info, collapse = "; ")
     [23:22:04.869] if (!has_future) {
     [23:22:04.869] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [23:22:04.869] info)
     [23:22:04.869] }
     [23:22:04.869] else {
     [23:22:04.869] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [23:22:04.869] info, version)
     [23:22:04.869] }
     [23:22:04.869] base::stop(msg)
     [23:22:04.869] }
     [23:22:04.869] }
     [23:22:04.869] ...future.mc.cores.old <- base::getOption("mc.cores")
     [23:22:04.869] base::options(mc.cores = 1L)
     [23:22:04.869] }
     [23:22:04.869] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [23:22:04.869] }
     [23:22:04.869] }
     [23:22:04.869] if (base::is.na(TRUE)) {
     [23:22:04.869] }
     [23:22:04.869] else {
     [23:22:04.869] if (TRUE) {
     [23:22:04.869] ...future.stdout <- base::rawConnection(base::raw(0L),
     [23:22:04.869] open = "w")
     [23:22:04.869] }
     [23:22:04.869] else {
     [23:22:04.869] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [23:22:04.869] windows = "NUL", "/dev/null"), open = "w")
     [23:22:04.869] }
     [23:22:04.869] base::sink(...future.stdout, type = "output", split = FALSE)
     [23:22:04.869] base::on.exit(if (!base::is.null(...future.stdout)) {
     [23:22:04.869] base::sink(type = "output", split = FALSE)
     [23:22:04.869] base::close(...future.stdout)
     [23:22:04.869] }, add = TRUE)
     [23:22:04.869] }
     [23:22:04.869] ...future.frame <- base::sys.nframe()
     [23:22:04.869] ...future.conditions <- base::list()
     [23:22:04.869] ...future.rng <- base::globalenv()$.Random.seed
     [23:22:04.869] ...future.result <- base::tryCatch({
     [23:22:04.869] base::withCallingHandlers({
     [23:22:04.869] ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
     [23:22:04.869] future::FutureResult(value = ...future.value$value,
     [23:22:04.869] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [23:22:04.869] ...future.rng), started = ...future.startTime,
     [23:22:04.869] version = "1.8")
     [23:22:04.869] }, condition = base::local({
     [23:22:04.869] c <- base::c
     [23:22:04.869] inherits <- base::inherits
     [23:22:04.869] invokeRestart <- base::invokeRestart
     [23:22:04.869] length <- base::length
     [23:22:04.869] list <- base::list
     [23:22:04.869] seq.int <- base::seq.int
     [23:22:04.869] signalCondition <- base::signalCondition
     [23:22:04.869] sys.calls <- base::sys.calls
     [23:22:04.869] Sys.time <- base::Sys.time
     [23:22:04.869] `[[` <- base::`[[`
     [23:22:04.869] `+` <- base::`+`
     [23:22:04.869] `<<-` <- base::`<<-`
     [23:22:04.869] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [23:22:04.869] calls[seq.int(from = from + 12L, to = length(calls) -
     [23:22:04.869] 3L)]
     [23:22:04.869] }
     [23:22:04.869] function(cond) {
     [23:22:04.869] if (inherits(cond, "error")) {
     [23:22:04.869] ...future.conditions[[length(...future.conditions) +
     [23:22:04.869] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [23:22:04.869] cond$call), timestamp = Sys.time(), signaled = 0L)
     [23:22:04.869] signalCondition(cond)
     [23:22:04.869] }
     [23:22:04.869] else if (inherits(cond, "condition")) {
     [23:22:04.869] signal <- FALSE && inherits(cond, character(0))
     [23:22:04.869] ...future.conditions[[length(...future.conditions) +
     [23:22:04.869] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [23:22:04.869] if (!signal) {
     [23:22:04.869] muffleCondition <- function (cond)
     [23:22:04.869] {
     [23:22:04.869] inherits <- base::inherits
     [23:22:04.869] invokeRestart <- base::invokeRestart
     [23:22:04.869] muffled <- FALSE
     [23:22:04.869] if (inherits(cond, "message")) {
     [23:22:04.869] invokeRestart("muffleMessage")
     [23:22:04.869] muffled <- TRUE
     [23:22:04.869] }
     [23:22:04.869] else if (inherits(cond, "warning")) {
     [23:22:04.869] invokeRestart("muffleWarning")
     [23:22:04.869] muffled <- TRUE
     [23:22:04.869] }
     [23:22:04.869] else if (inherits(cond, "condition")) {
     [23:22:04.869] computeRestarts <- base::computeRestarts
     [23:22:04.869] grepl <- base::grepl
     [23:22:04.869] is.null <- base::is.null
     [23:22:04.869] restarts <- computeRestarts(cond)
     [23:22:04.869] for (restart in restarts) {
     [23:22:04.869] name <- restart$name
     [23:22:04.869] if (is.null(name))
     [23:22:04.869] next
     [23:22:04.869] if (!grepl("^muffle", name))
     [23:22:04.869] next
     [23:22:04.869] invokeRestart(restart)
     [23:22:04.869] muffled <- TRUE
     [23:22:04.869] break
     [23:22:04.869] }
     [23:22:04.869] }
     [23:22:04.869] invisible(muffled)
     [23:22:04.869] }
     [23:22:04.869] muffleCondition(cond)
     [23:22:04.869] }
     [23:22:04.869] }
     [23:22:04.869] }
     [23:22:04.869] }))
     [23:22:04.869] }, error = function(ex) {
     [23:22:04.869] base::structure(base::list(value = NULL, visible = NULL,
     [23:22:04.869] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [23:22:04.869] ...future.rng), version = "1.8"), class = "FutureResult")
     [23:22:04.869] }, finally = {
     [23:22:04.869] {
     [23:22:04.869] {
     [23:22:04.869] base::options(mc.cores = ...future.mc.cores.old)
     [23:22:04.869] }
     [23:22:04.869] future::plan(list(function (expr, envir = parent.frame(),
     [23:22:04.869] substitute = TRUE, lazy = FALSE, seed = NULL,
     [23:22:04.869] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [23:22:04.869] earlySignal = FALSE, label = NULL, ...)
     [23:22:04.869] {
     [23:22:04.869] if (substitute)
     [23:22:04.869] expr <- substitute(expr)
     [23:22:04.869] if (is.function(workers))
     [23:22:04.869] workers <- workers()
     [23:22:04.869] workers <- as.integer(workers)
     [23:22:04.869] stop_if_not(is.finite(workers), workers >= 1L)
     [23:22:04.869] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [23:22:04.869] return(sequential(expr, envir = envir, substitute = FALSE,
     [23:22:04.869] lazy = lazy, seed = seed, globals = globals,
     [23:22:04.869] local = TRUE, label = label, ...))
     [23:22:04.869] }
     [23:22:04.869] oopts <- options(mc.cores = workers)
     [23:22:04.869] on.exit(options(oopts))
     [23:22:04.869] future <- MulticoreFuture(expr = expr, envir = envir,
     [23:22:04.869] substitute = FALSE, lazy = lazy, seed = seed,
     [23:22:04.869] globals = globals, workers = workers, earlySignal = earlySignal,
     [23:22:04.869] label = label, ...)
     [23:22:04.869] if (!future$lazy)
     [23:22:04.869] future <- run(future)
     [23:22:04.869] invisible(future)
     [23:22:04.869] }), .cleanup = FALSE, .init = FALSE)
     [23:22:04.869] }
     [23:22:04.869] base::options(...future.oldOptions)
     [23:22:04.869] })
     [23:22:04.869] Sys.time
     [23:22:04.869] if (base::is.na(TRUE)) {
     [23:22:04.869] }
     [23:22:04.869] else {
     [23:22:04.869] base::sink(type = "output", split = FALSE)
     [23:22:04.869] if (TRUE) {
     [23:22:04.869] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [23:22:04.869] }
     [23:22:04.869] else {
     [23:22:04.869] ...future.result["stdout"] <- base::list(NULL)
     [23:22:04.869] }
     [23:22:04.869] base::close(...future.stdout)
     [23:22:04.869] ...future.stdout <- NULL
     [23:22:04.869] }
     [23:22:04.869] ...future.result$conditions <- ...future.conditions
     [23:22:04.869] ...future.result
     [23:22:04.869] }
     [23:22:04.873] requestCore(): workers = 2
     [23:22:04.879] MulticoreFuture started
     [23:22:04.904] plan(): Setting new future strategy stack:
     [23:22:04.905] List of future strategies:
     [23:22:04.905] 1. sequential:
     [23:22:04.905] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [23:22:04.905] - tweaked: FALSE
     [23:22:04.905] - call: NULL
     [23:22:04.907] plan(): nbrOfWorkers() = 1
     [23:22:04.910] plan(): Setting new future strategy stack:
     [23:22:04.911] List of future strategies:
     [23:22:04.911] 1. multicore:
     [23:22:04.911] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [23:22:04.911] - tweaked: FALSE
     [23:22:04.911] - call: plan(multicore)
     [23:22:04.913] plan(): nbrOfWorkers() = 2
     Number of OpenMP threads in 'MulticoreFuture' future: 3
     'future.fork.multithreading.enable' = TRUE ... DONE
     'future.fork.multithreading.enable' = FALSE ...
     [23:22:04.928] getGlobalsAndPackages() ...
     [23:22:04.928] Searching for globals...
     [23:22:04.936] - globals found: [1] '::'
     [23:22:04.936] Searching for globals ... DONE
     [23:22:04.937] Resolving globals: FALSE
     [23:22:04.938]
     [23:22:04.938]
     [23:22:04.938] getGlobalsAndPackages() ... DONE
     [23:22:04.939] - Evaluate future in single-threaded mode ...
     [23:22:04.940] supports_omp_threads() = TRUE
     [23:22:04.940] - Force single-threaded processing for OpenMP
     [23:22:04.940] - Evaluate future in single-threaded mode ... DONE
     [23:22:04.943] Packages needed by the future expression (n = 0): <none>
     [23:22:04.944] Packages needed by future strategies (n = 0): <none>
     [23:22:04.952] {
     [23:22:04.952] {
     [23:22:04.952] ...future.startTime <- base::Sys.time()
     [23:22:04.952] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [23:22:04.952] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [23:22:04.952] future.globals.method = NULL, future.globals.onMissing = NULL,
     [23:22:04.952] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [23:22:04.952] future.resolve.recursive = NULL, width = 80L)
     [23:22:04.952] {
     [23:22:04.952] {
     [23:22:04.952] {
     [23:22:04.952] has_future <- base::requireNamespace("future",
     [23:22:04.952] quietly = TRUE)
     [23:22:04.952] version <- if (has_future)
     [23:22:04.952] utils::packageVersion("future")
     [23:22:04.952] else NULL
     [23:22:04.952] if (!has_future || version < "1.8.0") {
     [23:22:04.952] info <- base::c(r_version = base::gsub("R version ",
     [23:22:04.952] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [23:22:04.952] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [23:22:04.952] os = base::paste(base::Sys.info()[base::c("sysname",
     [23:22:04.952] "release", "version")], collapse = " "),
     [23:22:04.952] hostname = base::Sys.info()[["nodename"]])
     [23:22:04.952] info <- base::sprintf("%s: %s", base::names(info),
     [23:22:04.952] info)
     [23:22:04.952] info <- base::paste(info, collapse = "; ")
     [23:22:04.952] if (!has_future) {
     [23:22:04.952] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [23:22:04.952] info)
     [23:22:04.952] }
     [23:22:04.952] else {
     [23:22:04.952] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [23:22:04.952] info, version)
     [23:22:04.952] }
     [23:22:04.952] base::stop(msg)
     [23:22:04.952] }
     [23:22:04.952] }
     [23:22:04.952] ...future.mc.cores.old <- base::getOption("mc.cores")
     [23:22:04.952] base::options(mc.cores = 1L)
     [23:22:04.952] }
     [23:22:04.952] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [23:22:04.952] }
     [23:22:04.952] }
     [23:22:04.952] if (base::is.na(TRUE)) {
     [23:22:04.952] }
     [23:22:04.952] else {
     [23:22:04.952] if (TRUE) {
     [23:22:04.952] ...future.stdout <- base::rawConnection(base::raw(0L),
     [23:22:04.952] open = "w")
     [23:22:04.952] }
     [23:22:04.952] else {
     [23:22:04.952] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [23:22:04.952] windows = "NUL", "/dev/null"), open = "w")
     [23:22:04.952] }
     [23:22:04.952] base::sink(...future.stdout, type = "output", split = FALSE)
     [23:22:04.952] base::on.exit(if (!base::is.null(...future.stdout)) {
     [23:22:04.952] base::sink(type = "output", split = FALSE)
     [23:22:04.952] base::close(...future.stdout)
     [23:22:04.952] }, add = TRUE)
     [23:22:04.952] }
     [23:22:04.952] ...future.frame <- base::sys.nframe()
     [23:22:04.952] ...future.conditions <- base::list()
     [23:22:04.952] ...future.rng <- base::globalenv()$.Random.seed
     [23:22:04.952] ...future.result <- base::tryCatch({
     [23:22:04.952] base::withCallingHandlers({
     [23:22:04.952] ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
     [23:22:04.952] future::FutureResult(value = ...future.value$value,
     [23:22:04.952] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [23:22:04.952] ...future.rng), started = ...future.startTime,
     [23:22:04.952] version = "1.8")
     [23:22:04.952] }, condition = base::local({
     [23:22:04.952] c <- base::c
     [23:22:04.952] inherits <- base::inherits
     [23:22:04.952] invokeRestart <- base::invokeRestart
     [23:22:04.952] length <- base::length
     [23:22:04.952] list <- base::list
     [23:22:04.952] seq.int <- base::seq.int
     [23:22:04.952] signalCondition <- base::signalCondition
     [23:22:04.952] sys.calls <- base::sys.calls
     [23:22:04.952] Sys.time <- base::Sys.time
     [23:22:04.952] `[[` <- base::`[[`
     [23:22:04.952] `+` <- base::`+`
     [23:22:04.952] `<<-` <- base::`<<-`
     [23:22:04.952] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [23:22:04.952] calls[seq.int(from = from + 12L, to = length(calls) -
     [23:22:04.952] 3L)]
     [23:22:04.952] }
     [23:22:04.952] function(cond) {
     [23:22:04.952] if (inherits(cond, "error")) {
     [23:22:04.952] ...future.conditions[[length(...future.conditions) +
     [23:22:04.952] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [23:22:04.952] cond$call), timestamp = Sys.time(), signaled = 0L)
     [23:22:04.952] signalCondition(cond)
     [23:22:04.952] }
     [23:22:04.952] else if (inherits(cond, "condition")) {
     [23:22:04.952] signal <- FALSE && inherits(cond, character(0))
     [23:22:04.952] ...future.conditions[[length(...future.conditions) +
     [23:22:04.952] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [23:22:04.952] if (!signal) {
     [23:22:04.952] muffleCondition <- function (cond)
     [23:22:04.952] {
     [23:22:04.952] inherits <- base::inherits
     [23:22:04.952] invokeRestart <- base::invokeRestart
     [23:22:04.952] muffled <- FALSE
     [23:22:04.952] if (inherits(cond, "message")) {
     [23:22:04.952] invokeRestart("muffleMessage")
     [23:22:04.952] muffled <- TRUE
     [23:22:04.952] }
     [23:22:04.952] else if (inherits(cond, "warning")) {
     [23:22:04.952] invokeRestart("muffleWarning")
     [23:22:04.952] muffled <- TRUE
     [23:22:04.952] }
     [23:22:04.952] else if (inherits(cond, "condition")) {
     [23:22:04.952] computeRestarts <- base::computeRestarts
     [23:22:04.952] grepl <- base::grepl
     [23:22:04.952] is.null <- base::is.null
     [23:22:04.952] restarts <- computeRestarts(cond)
     [23:22:04.952] for (restart in restarts) {
     [23:22:04.952] name <- restart$name
     [23:22:04.952] if (is.null(name))
     [23:22:04.952] next
     [23:22:04.952] if (!grepl("^muffle", name))
     [23:22:04.952] next
     [23:22:04.952] invokeRestart(restart)
     [23:22:04.952] muffled <- TRUE
     [23:22:04.952] break
     [23:22:04.952] }
     [23:22:04.952] }
     [23:22:04.952] invisible(muffled)
     [23:22:04.952] }
     [23:22:04.952] muffleCondition(cond)
     [23:22:04.952] }
     [23:22:04.952] }
     [23:22:04.952] }
     [23:22:04.952] }))
     [23:22:04.952] }, error = function(ex) {
     [23:22:04.952] base::structure(base::list(value = NULL, visible = NULL,
     [23:22:04.952] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [23:22:04.952] ...future.rng), version = "1.8"), class = "FutureResult")
     [23:22:04.952] }, finally = {
     [23:22:04.952] {
     [23:22:04.952] {
     [23:22:04.952] base::options(mc.cores = ...future.mc.cores.old)
     [23:22:04.952] }
     [23:22:04.952] future::plan(list(function (expr, envir = parent.frame(),
     [23:22:04.952] substitute = TRUE, lazy = FALSE, seed = NULL,
     [23:22:04.952] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [23:22:04.952] earlySignal = FALSE, label = NULL, ...)
     [23:22:04.952] {
     [23:22:04.952] if (substitute)
     [23:22:04.952] expr <- substitute(expr)
     [23:22:04.952] if (is.function(workers))
     [23:22:04.952] workers <- workers()
     [23:22:04.952] workers <- as.integer(workers)
     [23:22:04.952] stop_if_not(is.finite(workers), workers >= 1L)
     [23:22:04.952] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [23:22:04.952] return(sequential(expr, envir = envir, substitute = FALSE,
     [23:22:04.952] lazy = lazy, seed = seed, globals = globals,
     [23:22:04.952] local = TRUE, label = label, ...))
     [23:22:04.952] }
     [23:22:04.952] oopts <- options(mc.cores = workers)
     [23:22:04.952] on.exit(options(oopts))
     [23:22:04.952] future <- MulticoreFuture(expr = expr, envir = envir,
     [23:22:04.952] substitute = FALSE, lazy = lazy, seed = seed,
     [23:22:04.952] globals = globals, workers = workers, earlySignal = earlySignal,
     [23:22:04.952] label = label, ...)
     [23:22:04.952] if (!future$lazy)
     [23:22:04.952] future <- run(future)
     [23:22:04.952] invisible(future)
     [23:22:04.952] }), .cleanup = FALSE, .init = FALSE)
     [23:22:04.952] }
     [23:22:04.952] base::options(...future.oldOptions)
     [23:22:04.952] })
     [23:22:04.952] Sys.time
     [23:22:04.952] if (base::is.na(TRUE)) {
     [23:22:04.952] }
     [23:22:04.952] else {
     [23:22:04.952] base::sink(type = "output", split = FALSE)
     [23:22:04.952] if (TRUE) {
     [23:22:04.952] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [23:22:04.952] }
     [23:22:04.952] else {
     [23:22:04.952] ...future.result["stdout"] <- base::list(NULL)
     [23:22:04.952] }
     [23:22:04.952] base::close(...future.stdout)
     [23:22:04.952] ...future.stdout <- NULL
     [23:22:04.952] }
     [23:22:04.952] ...future.result$conditions <- ...future.conditions
     [23:22:04.952] ...future.result
     [23:22:04.952] }
     [23:22:04.955] requestCore(): workers = 2
     [23:22:04.959] MulticoreFuture started
     [23:22:04.965] plan(): Setting new future strategy stack:
     [23:22:04.966] List of future strategies:
     [23:22:04.966] 1. sequential:
     [23:22:04.966] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [23:22:04.966] - tweaked: FALSE
     [23:22:04.966] - call: NULL
     [23:22:04.983] plan(): nbrOfWorkers() = 1
     [23:22:05.017] plan(): Setting new future strategy stack:
     [23:22:05.018] List of future strategies:
     [23:22:05.018] 1. multicore:
     [23:22:05.018] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [23:22:05.018] - tweaked: FALSE
     [23:22:05.018] - call: plan(multicore)
     [23:22:05.020] 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/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
Flavor: r-devel-linux-x86_64-fedora-clang