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

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

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

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

> source("incl/start.R")
[17:26:04.882] plan(): Setting new future strategy stack:
[17:26:04.884] List of future strategies:
[17:26:04.884] 1. sequential:
[17:26:04.884]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:04.884]    - tweaked: FALSE
[17:26:04.884]    - call: future::plan("sequential")
[17:26:04.899] plan(): nbrOfWorkers() = 1
> 
> capture_journals <- future:::capture_journals
> 
> message("*** capture_journals() ...")
*** capture_journals() ...
> 
> slow_fcn <- function(x) {
+   Sys.sleep(0.5 + 1/x)
+ }
> 
> plan(multisession, workers = 2)
[17:26:04.908] plan(): Setting new future strategy stack:
[17:26:04.908] List of future strategies:
[17:26:04.908] 1. multisession:
[17:26:04.908]    - args: function (..., workers = 2, envir = parent.frame())
[17:26:04.908]    - tweaked: TRUE
[17:26:04.908]    - call: plan(multisession, workers = 2)
[17:26:04.922] plan(): plan_init() of 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:26:04.923] multisession:
[17:26:04.923] - args: function (..., workers = 2, envir = parent.frame())
[17:26:04.923] - tweaked: TRUE
[17:26:04.923] - call: plan(multisession, workers = 2)
[17:26:04.924] getGlobalsAndPackages() ...
[17:26:04.924] Not searching for globals
[17:26:04.925] - globals: [0] <none>
[17:26:04.925] getGlobalsAndPackages() ... DONE
[17:26:04.925] [local output] makeClusterPSOCK() ...
[17:26:04.953] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:26:04.960] [local output] Base port: 32973
[17:26:04.960] [local output] Getting setup options for 2 cluster nodes ...
[17:26:04.960] [local output]  - Node 1 of 2 ...
[17:26:04.961] [local output] localMachine=TRUE => revtunnel=FALSE

[17:26:04.962] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpGGcaSg/worker.rank=1.parallelly.parent=32360.7e68567c461b.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpGGcaSg/worker.rank=1.parallelly.parent=32360.7e68567c461b.pid\")"'
[17:26:05.287] - Possible to infer worker's PID: TRUE
[17:26:05.287] [local output] Rscript port: 32973

[17:26:05.288] [local output]  - Node 2 of 2 ...
[17:26:05.289] [local output] localMachine=TRUE => revtunnel=FALSE

[17:26:05.290] [local output] Rscript port: 32973

[17:26:05.290] [local output] Getting setup options for 2 cluster nodes ... done
[17:26:05.290] [local output]  - Parallel setup requested for some PSOCK nodes
[17:26:05.291] [local output] Setting up PSOCK nodes in parallel
[17:26:05.291] List of 36
[17:26:05.291]  $ worker          : chr "localhost"
[17:26:05.291]   ..- attr(*, "localhost")= logi TRUE
[17:26:05.291]  $ master          : chr "localhost"
[17:26:05.291]  $ port            : int 32973
[17:26:05.291]  $ connectTimeout  : num 120
[17:26:05.291]  $ timeout         : num 120
[17:26:05.291]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:26:05.291]  $ homogeneous     : logi TRUE
[17:26:05.291]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=capture_journals.R:32360:CRANWIN"| __truncated__
[17:26:05.291]  $ rscript_envs    : NULL
[17:26:05.291]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7" "D:/RCompile/recent/R/library"
[17:26:05.291]  $ rscript_startup : NULL
[17:26:05.291]  $ rscript_sh      : chr "cmd"
[17:26:05.291]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:26:05.291]  $ methods         : logi TRUE
[17:26:05.291]  $ socketOptions   : chr "no-delay"
[17:26:05.291]  $ useXDR          : logi FALSE
[17:26:05.291]  $ outfile         : chr "/dev/null"
[17:26:05.291]  $ renice          : int NA
[17:26:05.291]  $ rshcmd          : NULL
[17:26:05.291]  $ user            : chr(0) 
[17:26:05.291]  $ revtunnel       : logi FALSE
[17:26:05.291]  $ rshlogfile      : NULL
[17:26:05.291]  $ rshopts         : chr(0) 
[17:26:05.291]  $ rank            : int 1
[17:26:05.291]  $ manual          : logi FALSE
[17:26:05.291]  $ dryrun          : logi FALSE
[17:26:05.291]  $ quiet           : logi FALSE
[17:26:05.291]  $ setup_strategy  : chr "parallel"
[17:26:05.291]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:26:05.291]  $ pidfile         : chr "D:/temp/RtmpGGcaSg/worker.rank=1.parallelly.parent=32360.7e68567c461b.pid"
[17:26:05.291]  $ rshcmd_label    : NULL
[17:26:05.291]  $ rsh_call        : NULL
[17:26:05.291]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:26:05.291]  $ localMachine    : logi TRUE
[17:26:05.291]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:26:05.291]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:26:05.291]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:26:05.291]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:26:05.291]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:26:05.291]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[17:26:05.291]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:26:05.291]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:26:05.291]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:26:05.291]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:26:05.291]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:26:05.291]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:26:05.291]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:26:05.291]  $ arguments       :List of 28
[17:26:05.291]   ..$ worker          : chr "localhost"
[17:26:05.291]   ..$ master          : NULL
[17:26:05.291]   ..$ port            : int 32973
[17:26:05.291]   ..$ connectTimeout  : num 120
[17:26:05.291]   ..$ timeout         : num 120
[17:26:05.291]   ..$ rscript         : NULL
[17:26:05.291]   ..$ homogeneous     : NULL
[17:26:05.291]   ..$ rscript_args    : NULL
[17:26:05.291]   ..$ rscript_envs    : NULL
[17:26:05.291]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7" "D:/RCompile/recent/R/library"
[17:26:05.291]   ..$ rscript_startup : NULL
[17:26:05.291]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[17:26:05.291]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:26:05.291]   ..$ methods         : logi TRUE
[17:26:05.291]   ..$ socketOptions   : chr "no-delay"
[17:26:05.291]   ..$ useXDR          : logi FALSE
[17:26:05.291]   ..$ outfile         : chr "/dev/null"
[17:26:05.291]   ..$ renice          : int NA
[17:26:05.291]   ..$ rshcmd          : NULL
[17:26:05.291]   ..$ user            : NULL
[17:26:05.291]   ..$ revtunnel       : logi NA
[17:26:05.291]   ..$ rshlogfile      : NULL
[17:26:05.291]   ..$ rshopts         : NULL
[17:26:05.291]   ..$ rank            : int 1
[17:26:05.291]   ..$ manual          : logi FALSE
[17:26:05.291]   ..$ dryrun          : logi FALSE
[17:26:05.291]   ..$ quiet           : logi FALSE
[17:26:05.291]   ..$ setup_strategy  : chr "parallel"
[17:26:05.291]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:26:05.315] [local output] System call to launch all workers:
[17:26:05.315] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=capture_journals.R:32360:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpGGcaSg/worker.rank=1.parallelly.parent=32360.7e68567c461b.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=32973 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:26:05.315] [local output] Starting PSOCK main server
[17:26:05.321] [local output] Workers launched
[17:26:05.321] [local output] Waiting for workers to connect back
[17:26:05.321]  - [local output] 0 workers out of 2 ready
[17:26:05.488]  - [local output] 0 workers out of 2 ready
[17:26:05.489]  - [local output] 1 workers out of 2 ready
[17:26:05.489]  - [local output] 2 workers out of 2 ready
[17:26:05.489] [local output] Launching of workers completed
[17:26:05.490] [local output] Collecting session information from workers
[17:26:05.491] [local output]  - Worker #1 of 2
[17:26:05.491] [local output]  - Worker #2 of 2
[17:26:05.492] [local output] makeClusterPSOCK() ... done
[17:26:05.505] Packages needed by the future expression (n = 0): <none>
[17:26:05.505] Packages needed by future strategies (n = 0): <none>
[17:26:05.506] {
[17:26:05.506]     {
[17:26:05.506]         {
[17:26:05.506]             ...future.startTime <- base::Sys.time()
[17:26:05.506]             {
[17:26:05.506]                 {
[17:26:05.506]                   {
[17:26:05.506]                     {
[17:26:05.506]                       base::local({
[17:26:05.506]                         has_future <- base::requireNamespace("future", 
[17:26:05.506]                           quietly = TRUE)
[17:26:05.506]                         if (has_future) {
[17:26:05.506]                           ns <- base::getNamespace("future")
[17:26:05.506]                           version <- ns[[".package"]][["version"]]
[17:26:05.506]                           if (is.null(version)) 
[17:26:05.506]                             version <- utils::packageVersion("future")
[17:26:05.506]                         }
[17:26:05.506]                         else {
[17:26:05.506]                           version <- NULL
[17:26:05.506]                         }
[17:26:05.506]                         if (!has_future || version < "1.8.0") {
[17:26:05.506]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:05.506]                             "", base::R.version$version.string), 
[17:26:05.506]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:05.506]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:05.506]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:05.506]                               "release", "version")], collapse = " "), 
[17:26:05.506]                             hostname = base::Sys.info()[["nodename"]])
[17:26:05.506]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:05.506]                             info)
[17:26:05.506]                           info <- base::paste(info, collapse = "; ")
[17:26:05.506]                           if (!has_future) {
[17:26:05.506]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:05.506]                               info)
[17:26:05.506]                           }
[17:26:05.506]                           else {
[17:26:05.506]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:05.506]                               info, version)
[17:26:05.506]                           }
[17:26:05.506]                           base::stop(msg)
[17:26:05.506]                         }
[17:26:05.506]                       })
[17:26:05.506]                     }
[17:26:05.506]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:05.506]                     base::options(mc.cores = 1L)
[17:26:05.506]                   }
[17:26:05.506]                   ...future.strategy.old <- future::plan("list")
[17:26:05.506]                   options(future.plan = NULL)
[17:26:05.506]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:05.506]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:05.506]                 }
[17:26:05.506]                 ...future.workdir <- getwd()
[17:26:05.506]             }
[17:26:05.506]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:05.506]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:05.506]         }
[17:26:05.506]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:05.506]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:05.506]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:05.506]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:05.506]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:05.506]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:05.506]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:05.506]             base::names(...future.oldOptions))
[17:26:05.506]     }
[17:26:05.506]     if (FALSE) {
[17:26:05.506]     }
[17:26:05.506]     else {
[17:26:05.506]         if (TRUE) {
[17:26:05.506]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:05.506]                 open = "w")
[17:26:05.506]         }
[17:26:05.506]         else {
[17:26:05.506]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:05.506]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:05.506]         }
[17:26:05.506]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:05.506]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:05.506]             base::sink(type = "output", split = FALSE)
[17:26:05.506]             base::close(...future.stdout)
[17:26:05.506]         }, add = TRUE)
[17:26:05.506]     }
[17:26:05.506]     ...future.frame <- base::sys.nframe()
[17:26:05.506]     ...future.conditions <- base::list()
[17:26:05.506]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:05.506]     if (FALSE) {
[17:26:05.506]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:05.506]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:05.506]     }
[17:26:05.506]     ...future.result <- base::tryCatch({
[17:26:05.506]         base::withCallingHandlers({
[17:26:05.506]             ...future.value <- base::withVisible(base::local({
[17:26:05.506]                 ...future.makeSendCondition <- base::local({
[17:26:05.506]                   sendCondition <- NULL
[17:26:05.506]                   function(frame = 1L) {
[17:26:05.506]                     if (is.function(sendCondition)) 
[17:26:05.506]                       return(sendCondition)
[17:26:05.506]                     ns <- getNamespace("parallel")
[17:26:05.506]                     if (exists("sendData", mode = "function", 
[17:26:05.506]                       envir = ns)) {
[17:26:05.506]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:05.506]                         envir = ns)
[17:26:05.506]                       envir <- sys.frame(frame)
[17:26:05.506]                       master <- NULL
[17:26:05.506]                       while (!identical(envir, .GlobalEnv) && 
[17:26:05.506]                         !identical(envir, emptyenv())) {
[17:26:05.506]                         if (exists("master", mode = "list", envir = envir, 
[17:26:05.506]                           inherits = FALSE)) {
[17:26:05.506]                           master <- get("master", mode = "list", 
[17:26:05.506]                             envir = envir, inherits = FALSE)
[17:26:05.506]                           if (inherits(master, c("SOCKnode", 
[17:26:05.506]                             "SOCK0node"))) {
[17:26:05.506]                             sendCondition <<- function(cond) {
[17:26:05.506]                               data <- list(type = "VALUE", value = cond, 
[17:26:05.506]                                 success = TRUE)
[17:26:05.506]                               parallel_sendData(master, data)
[17:26:05.506]                             }
[17:26:05.506]                             return(sendCondition)
[17:26:05.506]                           }
[17:26:05.506]                         }
[17:26:05.506]                         frame <- frame + 1L
[17:26:05.506]                         envir <- sys.frame(frame)
[17:26:05.506]                       }
[17:26:05.506]                     }
[17:26:05.506]                     sendCondition <<- function(cond) NULL
[17:26:05.506]                   }
[17:26:05.506]                 })
[17:26:05.506]                 withCallingHandlers({
[17:26:05.506]                   NA
[17:26:05.506]                 }, immediateCondition = function(cond) {
[17:26:05.506]                   sendCondition <- ...future.makeSendCondition()
[17:26:05.506]                   sendCondition(cond)
[17:26:05.506]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:05.506]                   {
[17:26:05.506]                     inherits <- base::inherits
[17:26:05.506]                     invokeRestart <- base::invokeRestart
[17:26:05.506]                     is.null <- base::is.null
[17:26:05.506]                     muffled <- FALSE
[17:26:05.506]                     if (inherits(cond, "message")) {
[17:26:05.506]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:05.506]                       if (muffled) 
[17:26:05.506]                         invokeRestart("muffleMessage")
[17:26:05.506]                     }
[17:26:05.506]                     else if (inherits(cond, "warning")) {
[17:26:05.506]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:05.506]                       if (muffled) 
[17:26:05.506]                         invokeRestart("muffleWarning")
[17:26:05.506]                     }
[17:26:05.506]                     else if (inherits(cond, "condition")) {
[17:26:05.506]                       if (!is.null(pattern)) {
[17:26:05.506]                         computeRestarts <- base::computeRestarts
[17:26:05.506]                         grepl <- base::grepl
[17:26:05.506]                         restarts <- computeRestarts(cond)
[17:26:05.506]                         for (restart in restarts) {
[17:26:05.506]                           name <- restart$name
[17:26:05.506]                           if (is.null(name)) 
[17:26:05.506]                             next
[17:26:05.506]                           if (!grepl(pattern, name)) 
[17:26:05.506]                             next
[17:26:05.506]                           invokeRestart(restart)
[17:26:05.506]                           muffled <- TRUE
[17:26:05.506]                           break
[17:26:05.506]                         }
[17:26:05.506]                       }
[17:26:05.506]                     }
[17:26:05.506]                     invisible(muffled)
[17:26:05.506]                   }
[17:26:05.506]                   muffleCondition(cond)
[17:26:05.506]                 })
[17:26:05.506]             }))
[17:26:05.506]             future::FutureResult(value = ...future.value$value, 
[17:26:05.506]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:05.506]                   ...future.rng), globalenv = if (FALSE) 
[17:26:05.506]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:05.506]                     ...future.globalenv.names))
[17:26:05.506]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:05.506]         }, condition = base::local({
[17:26:05.506]             c <- base::c
[17:26:05.506]             inherits <- base::inherits
[17:26:05.506]             invokeRestart <- base::invokeRestart
[17:26:05.506]             length <- base::length
[17:26:05.506]             list <- base::list
[17:26:05.506]             seq.int <- base::seq.int
[17:26:05.506]             signalCondition <- base::signalCondition
[17:26:05.506]             sys.calls <- base::sys.calls
[17:26:05.506]             `[[` <- base::`[[`
[17:26:05.506]             `+` <- base::`+`
[17:26:05.506]             `<<-` <- base::`<<-`
[17:26:05.506]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:05.506]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:05.506]                   3L)]
[17:26:05.506]             }
[17:26:05.506]             function(cond) {
[17:26:05.506]                 is_error <- inherits(cond, "error")
[17:26:05.506]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:05.506]                   NULL)
[17:26:05.506]                 if (is_error) {
[17:26:05.506]                   sessionInformation <- function() {
[17:26:05.506]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:05.506]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:05.506]                       search = base::search(), system = base::Sys.info())
[17:26:05.506]                   }
[17:26:05.506]                   ...future.conditions[[length(...future.conditions) + 
[17:26:05.506]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:05.506]                     cond$call), session = sessionInformation(), 
[17:26:05.506]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:05.506]                   signalCondition(cond)
[17:26:05.506]                 }
[17:26:05.506]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:05.506]                 "immediateCondition"))) {
[17:26:05.506]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:05.506]                   ...future.conditions[[length(...future.conditions) + 
[17:26:05.506]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:05.506]                   if (TRUE && !signal) {
[17:26:05.506]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:05.506]                     {
[17:26:05.506]                       inherits <- base::inherits
[17:26:05.506]                       invokeRestart <- base::invokeRestart
[17:26:05.506]                       is.null <- base::is.null
[17:26:05.506]                       muffled <- FALSE
[17:26:05.506]                       if (inherits(cond, "message")) {
[17:26:05.506]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:05.506]                         if (muffled) 
[17:26:05.506]                           invokeRestart("muffleMessage")
[17:26:05.506]                       }
[17:26:05.506]                       else if (inherits(cond, "warning")) {
[17:26:05.506]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:05.506]                         if (muffled) 
[17:26:05.506]                           invokeRestart("muffleWarning")
[17:26:05.506]                       }
[17:26:05.506]                       else if (inherits(cond, "condition")) {
[17:26:05.506]                         if (!is.null(pattern)) {
[17:26:05.506]                           computeRestarts <- base::computeRestarts
[17:26:05.506]                           grepl <- base::grepl
[17:26:05.506]                           restarts <- computeRestarts(cond)
[17:26:05.506]                           for (restart in restarts) {
[17:26:05.506]                             name <- restart$name
[17:26:05.506]                             if (is.null(name)) 
[17:26:05.506]                               next
[17:26:05.506]                             if (!grepl(pattern, name)) 
[17:26:05.506]                               next
[17:26:05.506]                             invokeRestart(restart)
[17:26:05.506]                             muffled <- TRUE
[17:26:05.506]                             break
[17:26:05.506]                           }
[17:26:05.506]                         }
[17:26:05.506]                       }
[17:26:05.506]                       invisible(muffled)
[17:26:05.506]                     }
[17:26:05.506]                     muffleCondition(cond, pattern = "^muffle")
[17:26:05.506]                   }
[17:26:05.506]                 }
[17:26:05.506]                 else {
[17:26:05.506]                   if (TRUE) {
[17:26:05.506]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:05.506]                     {
[17:26:05.506]                       inherits <- base::inherits
[17:26:05.506]                       invokeRestart <- base::invokeRestart
[17:26:05.506]                       is.null <- base::is.null
[17:26:05.506]                       muffled <- FALSE
[17:26:05.506]                       if (inherits(cond, "message")) {
[17:26:05.506]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:05.506]                         if (muffled) 
[17:26:05.506]                           invokeRestart("muffleMessage")
[17:26:05.506]                       }
[17:26:05.506]                       else if (inherits(cond, "warning")) {
[17:26:05.506]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:05.506]                         if (muffled) 
[17:26:05.506]                           invokeRestart("muffleWarning")
[17:26:05.506]                       }
[17:26:05.506]                       else if (inherits(cond, "condition")) {
[17:26:05.506]                         if (!is.null(pattern)) {
[17:26:05.506]                           computeRestarts <- base::computeRestarts
[17:26:05.506]                           grepl <- base::grepl
[17:26:05.506]                           restarts <- computeRestarts(cond)
[17:26:05.506]                           for (restart in restarts) {
[17:26:05.506]                             name <- restart$name
[17:26:05.506]                             if (is.null(name)) 
[17:26:05.506]                               next
[17:26:05.506]                             if (!grepl(pattern, name)) 
[17:26:05.506]                               next
[17:26:05.506]                             invokeRestart(restart)
[17:26:05.506]                             muffled <- TRUE
[17:26:05.506]                             break
[17:26:05.506]                           }
[17:26:05.506]                         }
[17:26:05.506]                       }
[17:26:05.506]                       invisible(muffled)
[17:26:05.506]                     }
[17:26:05.506]                     muffleCondition(cond, pattern = "^muffle")
[17:26:05.506]                   }
[17:26:05.506]                 }
[17:26:05.506]             }
[17:26:05.506]         }))
[17:26:05.506]     }, error = function(ex) {
[17:26:05.506]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:05.506]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:05.506]                 ...future.rng), started = ...future.startTime, 
[17:26:05.506]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:05.506]             version = "1.8"), class = "FutureResult")
[17:26:05.506]     }, finally = {
[17:26:05.506]         if (!identical(...future.workdir, getwd())) 
[17:26:05.506]             setwd(...future.workdir)
[17:26:05.506]         {
[17:26:05.506]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:05.506]                 ...future.oldOptions$nwarnings <- NULL
[17:26:05.506]             }
[17:26:05.506]             base::options(...future.oldOptions)
[17:26:05.506]             if (.Platform$OS.type == "windows") {
[17:26:05.506]                 old_names <- names(...future.oldEnvVars)
[17:26:05.506]                 envs <- base::Sys.getenv()
[17:26:05.506]                 names <- names(envs)
[17:26:05.506]                 common <- intersect(names, old_names)
[17:26:05.506]                 added <- setdiff(names, old_names)
[17:26:05.506]                 removed <- setdiff(old_names, names)
[17:26:05.506]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:05.506]                   envs[common]]
[17:26:05.506]                 NAMES <- toupper(changed)
[17:26:05.506]                 args <- list()
[17:26:05.506]                 for (kk in seq_along(NAMES)) {
[17:26:05.506]                   name <- changed[[kk]]
[17:26:05.506]                   NAME <- NAMES[[kk]]
[17:26:05.506]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:05.506]                     next
[17:26:05.506]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:05.506]                 }
[17:26:05.506]                 NAMES <- toupper(added)
[17:26:05.506]                 for (kk in seq_along(NAMES)) {
[17:26:05.506]                   name <- added[[kk]]
[17:26:05.506]                   NAME <- NAMES[[kk]]
[17:26:05.506]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:05.506]                     next
[17:26:05.506]                   args[[name]] <- ""
[17:26:05.506]                 }
[17:26:05.506]                 NAMES <- toupper(removed)
[17:26:05.506]                 for (kk in seq_along(NAMES)) {
[17:26:05.506]                   name <- removed[[kk]]
[17:26:05.506]                   NAME <- NAMES[[kk]]
[17:26:05.506]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:05.506]                     next
[17:26:05.506]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:05.506]                 }
[17:26:05.506]                 if (length(args) > 0) 
[17:26:05.506]                   base::do.call(base::Sys.setenv, args = args)
[17:26:05.506]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:05.506]             }
[17:26:05.506]             else {
[17:26:05.506]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:05.506]             }
[17:26:05.506]             {
[17:26:05.506]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:05.506]                   0L) {
[17:26:05.506]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:05.506]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:05.506]                   base::options(opts)
[17:26:05.506]                 }
[17:26:05.506]                 {
[17:26:05.506]                   {
[17:26:05.506]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:05.506]                     NULL
[17:26:05.506]                   }
[17:26:05.506]                   options(future.plan = NULL)
[17:26:05.506]                   if (is.na(NA_character_)) 
[17:26:05.506]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:05.506]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:05.506]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:05.506]                     .init = FALSE)
[17:26:05.506]                 }
[17:26:05.506]             }
[17:26:05.506]         }
[17:26:05.506]     })
[17:26:05.506]     if (TRUE) {
[17:26:05.506]         base::sink(type = "output", split = FALSE)
[17:26:05.506]         if (TRUE) {
[17:26:05.506]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:05.506]         }
[17:26:05.506]         else {
[17:26:05.506]             ...future.result["stdout"] <- base::list(NULL)
[17:26:05.506]         }
[17:26:05.506]         base::close(...future.stdout)
[17:26:05.506]         ...future.stdout <- NULL
[17:26:05.506]     }
[17:26:05.506]     ...future.result$conditions <- ...future.conditions
[17:26:05.506]     ...future.result$finished <- base::Sys.time()
[17:26:05.506]     ...future.result
[17:26:05.506] }
[17:26:05.590] MultisessionFuture started
[17:26:05.590] result() for ClusterFuture ...
[17:26:05.591] receiveMessageFromWorker() for ClusterFuture ...
[17:26:05.591] - Validating connection of MultisessionFuture
[17:26:05.642] - received message: FutureResult
[17:26:05.642] - Received FutureResult
[17:26:05.646] - Erased future from FutureRegistry
[17:26:05.646] result() for ClusterFuture ...
[17:26:05.646] - result already collected: FutureResult
[17:26:05.647] result() for ClusterFuture ... done
[17:26:05.647] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:05.647] result() for ClusterFuture ... done
[17:26:05.647] result() for ClusterFuture ...
[17:26:05.647] - result already collected: FutureResult
[17:26:05.647] result() for ClusterFuture ... done
[17:26:05.648] plan(): plan_init() of 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:26:05.648] plan(): nbrOfWorkers() = 2
> js <- capture_journals({
+   fs <- lapply(3:1, FUN = function(x) future(slow_fcn(x)))
+   vs <- value(fs)
+ })
[17:26:05.648] getGlobalsAndPackages() ...
[17:26:05.649] Searching for globals...
[17:26:05.655] - globals found: [6] 'slow_fcn', 'x', '{', 'Sys.sleep', '+', '/'
[17:26:05.655] Searching for globals ... DONE
[17:26:05.656] Resolving globals: FALSE
[17:26:05.657] The total size of the 2 globals is 1.20 KiB (1232 bytes)
[17:26:05.658] The total size of the 2 globals exported for future expression ('slow_fcn(x)') is 1.20 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'slow_fcn' (1.15 KiB of class 'function') and 'x' (56 bytes of class 'numeric')
[17:26:05.658] - globals: [2] 'slow_fcn', 'x'
[17:26:05.658] 
[17:26:05.658] getGlobalsAndPackages() ... DONE
[17:26:05.660] run() for 'Future' ...
[17:26:05.660] - state: 'created'
[17:26:05.661] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:05.673] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:05.673] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:05.673]   - Field: 'node'
[17:26:05.673]   - Field: 'label'
[17:26:05.674]   - Field: 'local'
[17:26:05.674]   - Field: 'owner'
[17:26:05.674]   - Field: 'envir'
[17:26:05.674]   - Field: 'workers'
[17:26:05.674]   - Field: 'packages'
[17:26:05.674]   - Field: 'gc'
[17:26:05.675]   - Field: 'conditions'
[17:26:05.675]   - Field: 'persistent'
[17:26:05.675]   - Field: 'expr'
[17:26:05.675]   - Field: 'uuid'
[17:26:05.675]   - Field: 'seed'
[17:26:05.676]   - Field: 'version'
[17:26:05.676]   - Field: 'result'
[17:26:05.676]   - Field: 'asynchronous'
[17:26:05.676]   - Field: 'calls'
[17:26:05.676]   - Field: 'globals'
[17:26:05.677]   - Field: 'stdout'
[17:26:05.677]   - Field: 'earlySignal'
[17:26:05.677]   - Field: 'lazy'
[17:26:05.677]   - Field: 'state'
[17:26:05.677] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:05.678] - Launch lazy future ...
[17:26:05.678] Packages needed by the future expression (n = 0): <none>
[17:26:05.678] Packages needed by future strategies (n = 0): <none>
[17:26:05.679] {
[17:26:05.679]     {
[17:26:05.679]         {
[17:26:05.679]             ...future.startTime <- base::Sys.time()
[17:26:05.679]             {
[17:26:05.679]                 {
[17:26:05.679]                   {
[17:26:05.679]                     {
[17:26:05.679]                       base::local({
[17:26:05.679]                         has_future <- base::requireNamespace("future", 
[17:26:05.679]                           quietly = TRUE)
[17:26:05.679]                         if (has_future) {
[17:26:05.679]                           ns <- base::getNamespace("future")
[17:26:05.679]                           version <- ns[[".package"]][["version"]]
[17:26:05.679]                           if (is.null(version)) 
[17:26:05.679]                             version <- utils::packageVersion("future")
[17:26:05.679]                         }
[17:26:05.679]                         else {
[17:26:05.679]                           version <- NULL
[17:26:05.679]                         }
[17:26:05.679]                         if (!has_future || version < "1.8.0") {
[17:26:05.679]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:05.679]                             "", base::R.version$version.string), 
[17:26:05.679]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:05.679]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:05.679]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:05.679]                               "release", "version")], collapse = " "), 
[17:26:05.679]                             hostname = base::Sys.info()[["nodename"]])
[17:26:05.679]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:05.679]                             info)
[17:26:05.679]                           info <- base::paste(info, collapse = "; ")
[17:26:05.679]                           if (!has_future) {
[17:26:05.679]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:05.679]                               info)
[17:26:05.679]                           }
[17:26:05.679]                           else {
[17:26:05.679]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:05.679]                               info, version)
[17:26:05.679]                           }
[17:26:05.679]                           base::stop(msg)
[17:26:05.679]                         }
[17:26:05.679]                       })
[17:26:05.679]                     }
[17:26:05.679]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:05.679]                     base::options(mc.cores = 1L)
[17:26:05.679]                   }
[17:26:05.679]                   ...future.strategy.old <- future::plan("list")
[17:26:05.679]                   options(future.plan = NULL)
[17:26:05.679]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:05.679]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:05.679]                 }
[17:26:05.679]                 ...future.workdir <- getwd()
[17:26:05.679]             }
[17:26:05.679]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:05.679]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:05.679]         }
[17:26:05.679]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:05.679]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:05.679]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:05.679]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:05.679]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:05.679]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:05.679]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:05.679]             base::names(...future.oldOptions))
[17:26:05.679]     }
[17:26:05.679]     if (FALSE) {
[17:26:05.679]     }
[17:26:05.679]     else {
[17:26:05.679]         if (TRUE) {
[17:26:05.679]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:05.679]                 open = "w")
[17:26:05.679]         }
[17:26:05.679]         else {
[17:26:05.679]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:05.679]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:05.679]         }
[17:26:05.679]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:05.679]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:05.679]             base::sink(type = "output", split = FALSE)
[17:26:05.679]             base::close(...future.stdout)
[17:26:05.679]         }, add = TRUE)
[17:26:05.679]     }
[17:26:05.679]     ...future.frame <- base::sys.nframe()
[17:26:05.679]     ...future.conditions <- base::list()
[17:26:05.679]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:05.679]     if (FALSE) {
[17:26:05.679]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:05.679]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:05.679]     }
[17:26:05.679]     ...future.result <- base::tryCatch({
[17:26:05.679]         base::withCallingHandlers({
[17:26:05.679]             ...future.value <- base::withVisible(base::local({
[17:26:05.679]                 ...future.makeSendCondition <- base::local({
[17:26:05.679]                   sendCondition <- NULL
[17:26:05.679]                   function(frame = 1L) {
[17:26:05.679]                     if (is.function(sendCondition)) 
[17:26:05.679]                       return(sendCondition)
[17:26:05.679]                     ns <- getNamespace("parallel")
[17:26:05.679]                     if (exists("sendData", mode = "function", 
[17:26:05.679]                       envir = ns)) {
[17:26:05.679]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:05.679]                         envir = ns)
[17:26:05.679]                       envir <- sys.frame(frame)
[17:26:05.679]                       master <- NULL
[17:26:05.679]                       while (!identical(envir, .GlobalEnv) && 
[17:26:05.679]                         !identical(envir, emptyenv())) {
[17:26:05.679]                         if (exists("master", mode = "list", envir = envir, 
[17:26:05.679]                           inherits = FALSE)) {
[17:26:05.679]                           master <- get("master", mode = "list", 
[17:26:05.679]                             envir = envir, inherits = FALSE)
[17:26:05.679]                           if (inherits(master, c("SOCKnode", 
[17:26:05.679]                             "SOCK0node"))) {
[17:26:05.679]                             sendCondition <<- function(cond) {
[17:26:05.679]                               data <- list(type = "VALUE", value = cond, 
[17:26:05.679]                                 success = TRUE)
[17:26:05.679]                               parallel_sendData(master, data)
[17:26:05.679]                             }
[17:26:05.679]                             return(sendCondition)
[17:26:05.679]                           }
[17:26:05.679]                         }
[17:26:05.679]                         frame <- frame + 1L
[17:26:05.679]                         envir <- sys.frame(frame)
[17:26:05.679]                       }
[17:26:05.679]                     }
[17:26:05.679]                     sendCondition <<- function(cond) NULL
[17:26:05.679]                   }
[17:26:05.679]                 })
[17:26:05.679]                 withCallingHandlers({
[17:26:05.679]                   slow_fcn(x)
[17:26:05.679]                 }, immediateCondition = function(cond) {
[17:26:05.679]                   sendCondition <- ...future.makeSendCondition()
[17:26:05.679]                   sendCondition(cond)
[17:26:05.679]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:05.679]                   {
[17:26:05.679]                     inherits <- base::inherits
[17:26:05.679]                     invokeRestart <- base::invokeRestart
[17:26:05.679]                     is.null <- base::is.null
[17:26:05.679]                     muffled <- FALSE
[17:26:05.679]                     if (inherits(cond, "message")) {
[17:26:05.679]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:05.679]                       if (muffled) 
[17:26:05.679]                         invokeRestart("muffleMessage")
[17:26:05.679]                     }
[17:26:05.679]                     else if (inherits(cond, "warning")) {
[17:26:05.679]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:05.679]                       if (muffled) 
[17:26:05.679]                         invokeRestart("muffleWarning")
[17:26:05.679]                     }
[17:26:05.679]                     else if (inherits(cond, "condition")) {
[17:26:05.679]                       if (!is.null(pattern)) {
[17:26:05.679]                         computeRestarts <- base::computeRestarts
[17:26:05.679]                         grepl <- base::grepl
[17:26:05.679]                         restarts <- computeRestarts(cond)
[17:26:05.679]                         for (restart in restarts) {
[17:26:05.679]                           name <- restart$name
[17:26:05.679]                           if (is.null(name)) 
[17:26:05.679]                             next
[17:26:05.679]                           if (!grepl(pattern, name)) 
[17:26:05.679]                             next
[17:26:05.679]                           invokeRestart(restart)
[17:26:05.679]                           muffled <- TRUE
[17:26:05.679]                           break
[17:26:05.679]                         }
[17:26:05.679]                       }
[17:26:05.679]                     }
[17:26:05.679]                     invisible(muffled)
[17:26:05.679]                   }
[17:26:05.679]                   muffleCondition(cond)
[17:26:05.679]                 })
[17:26:05.679]             }))
[17:26:05.679]             future::FutureResult(value = ...future.value$value, 
[17:26:05.679]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:05.679]                   ...future.rng), globalenv = if (FALSE) 
[17:26:05.679]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:05.679]                     ...future.globalenv.names))
[17:26:05.679]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:05.679]         }, condition = base::local({
[17:26:05.679]             c <- base::c
[17:26:05.679]             inherits <- base::inherits
[17:26:05.679]             invokeRestart <- base::invokeRestart
[17:26:05.679]             length <- base::length
[17:26:05.679]             list <- base::list
[17:26:05.679]             seq.int <- base::seq.int
[17:26:05.679]             signalCondition <- base::signalCondition
[17:26:05.679]             sys.calls <- base::sys.calls
[17:26:05.679]             `[[` <- base::`[[`
[17:26:05.679]             `+` <- base::`+`
[17:26:05.679]             `<<-` <- base::`<<-`
[17:26:05.679]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:05.679]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:05.679]                   3L)]
[17:26:05.679]             }
[17:26:05.679]             function(cond) {
[17:26:05.679]                 is_error <- inherits(cond, "error")
[17:26:05.679]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:05.679]                   NULL)
[17:26:05.679]                 if (is_error) {
[17:26:05.679]                   sessionInformation <- function() {
[17:26:05.679]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:05.679]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:05.679]                       search = base::search(), system = base::Sys.info())
[17:26:05.679]                   }
[17:26:05.679]                   ...future.conditions[[length(...future.conditions) + 
[17:26:05.679]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:05.679]                     cond$call), session = sessionInformation(), 
[17:26:05.679]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:05.679]                   signalCondition(cond)
[17:26:05.679]                 }
[17:26:05.679]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:05.679]                 "immediateCondition"))) {
[17:26:05.679]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:05.679]                   ...future.conditions[[length(...future.conditions) + 
[17:26:05.679]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:05.679]                   if (TRUE && !signal) {
[17:26:05.679]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:05.679]                     {
[17:26:05.679]                       inherits <- base::inherits
[17:26:05.679]                       invokeRestart <- base::invokeRestart
[17:26:05.679]                       is.null <- base::is.null
[17:26:05.679]                       muffled <- FALSE
[17:26:05.679]                       if (inherits(cond, "message")) {
[17:26:05.679]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:05.679]                         if (muffled) 
[17:26:05.679]                           invokeRestart("muffleMessage")
[17:26:05.679]                       }
[17:26:05.679]                       else if (inherits(cond, "warning")) {
[17:26:05.679]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:05.679]                         if (muffled) 
[17:26:05.679]                           invokeRestart("muffleWarning")
[17:26:05.679]                       }
[17:26:05.679]                       else if (inherits(cond, "condition")) {
[17:26:05.679]                         if (!is.null(pattern)) {
[17:26:05.679]                           computeRestarts <- base::computeRestarts
[17:26:05.679]                           grepl <- base::grepl
[17:26:05.679]                           restarts <- computeRestarts(cond)
[17:26:05.679]                           for (restart in restarts) {
[17:26:05.679]                             name <- restart$name
[17:26:05.679]                             if (is.null(name)) 
[17:26:05.679]                               next
[17:26:05.679]                             if (!grepl(pattern, name)) 
[17:26:05.679]                               next
[17:26:05.679]                             invokeRestart(restart)
[17:26:05.679]                             muffled <- TRUE
[17:26:05.679]                             break
[17:26:05.679]                           }
[17:26:05.679]                         }
[17:26:05.679]                       }
[17:26:05.679]                       invisible(muffled)
[17:26:05.679]                     }
[17:26:05.679]                     muffleCondition(cond, pattern = "^muffle")
[17:26:05.679]                   }
[17:26:05.679]                 }
[17:26:05.679]                 else {
[17:26:05.679]                   if (TRUE) {
[17:26:05.679]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:05.679]                     {
[17:26:05.679]                       inherits <- base::inherits
[17:26:05.679]                       invokeRestart <- base::invokeRestart
[17:26:05.679]                       is.null <- base::is.null
[17:26:05.679]                       muffled <- FALSE
[17:26:05.679]                       if (inherits(cond, "message")) {
[17:26:05.679]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:05.679]                         if (muffled) 
[17:26:05.679]                           invokeRestart("muffleMessage")
[17:26:05.679]                       }
[17:26:05.679]                       else if (inherits(cond, "warning")) {
[17:26:05.679]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:05.679]                         if (muffled) 
[17:26:05.679]                           invokeRestart("muffleWarning")
[17:26:05.679]                       }
[17:26:05.679]                       else if (inherits(cond, "condition")) {
[17:26:05.679]                         if (!is.null(pattern)) {
[17:26:05.679]                           computeRestarts <- base::computeRestarts
[17:26:05.679]                           grepl <- base::grepl
[17:26:05.679]                           restarts <- computeRestarts(cond)
[17:26:05.679]                           for (restart in restarts) {
[17:26:05.679]                             name <- restart$name
[17:26:05.679]                             if (is.null(name)) 
[17:26:05.679]                               next
[17:26:05.679]                             if (!grepl(pattern, name)) 
[17:26:05.679]                               next
[17:26:05.679]                             invokeRestart(restart)
[17:26:05.679]                             muffled <- TRUE
[17:26:05.679]                             break
[17:26:05.679]                           }
[17:26:05.679]                         }
[17:26:05.679]                       }
[17:26:05.679]                       invisible(muffled)
[17:26:05.679]                     }
[17:26:05.679]                     muffleCondition(cond, pattern = "^muffle")
[17:26:05.679]                   }
[17:26:05.679]                 }
[17:26:05.679]             }
[17:26:05.679]         }))
[17:26:05.679]     }, error = function(ex) {
[17:26:05.679]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:05.679]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:05.679]                 ...future.rng), started = ...future.startTime, 
[17:26:05.679]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:05.679]             version = "1.8"), class = "FutureResult")
[17:26:05.679]     }, finally = {
[17:26:05.679]         if (!identical(...future.workdir, getwd())) 
[17:26:05.679]             setwd(...future.workdir)
[17:26:05.679]         {
[17:26:05.679]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:05.679]                 ...future.oldOptions$nwarnings <- NULL
[17:26:05.679]             }
[17:26:05.679]             base::options(...future.oldOptions)
[17:26:05.679]             if (.Platform$OS.type == "windows") {
[17:26:05.679]                 old_names <- names(...future.oldEnvVars)
[17:26:05.679]                 envs <- base::Sys.getenv()
[17:26:05.679]                 names <- names(envs)
[17:26:05.679]                 common <- intersect(names, old_names)
[17:26:05.679]                 added <- setdiff(names, old_names)
[17:26:05.679]                 removed <- setdiff(old_names, names)
[17:26:05.679]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:05.679]                   envs[common]]
[17:26:05.679]                 NAMES <- toupper(changed)
[17:26:05.679]                 args <- list()
[17:26:05.679]                 for (kk in seq_along(NAMES)) {
[17:26:05.679]                   name <- changed[[kk]]
[17:26:05.679]                   NAME <- NAMES[[kk]]
[17:26:05.679]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:05.679]                     next
[17:26:05.679]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:05.679]                 }
[17:26:05.679]                 NAMES <- toupper(added)
[17:26:05.679]                 for (kk in seq_along(NAMES)) {
[17:26:05.679]                   name <- added[[kk]]
[17:26:05.679]                   NAME <- NAMES[[kk]]
[17:26:05.679]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:05.679]                     next
[17:26:05.679]                   args[[name]] <- ""
[17:26:05.679]                 }
[17:26:05.679]                 NAMES <- toupper(removed)
[17:26:05.679]                 for (kk in seq_along(NAMES)) {
[17:26:05.679]                   name <- removed[[kk]]
[17:26:05.679]                   NAME <- NAMES[[kk]]
[17:26:05.679]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:05.679]                     next
[17:26:05.679]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:05.679]                 }
[17:26:05.679]                 if (length(args) > 0) 
[17:26:05.679]                   base::do.call(base::Sys.setenv, args = args)
[17:26:05.679]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:05.679]             }
[17:26:05.679]             else {
[17:26:05.679]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:05.679]             }
[17:26:05.679]             {
[17:26:05.679]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:05.679]                   0L) {
[17:26:05.679]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:05.679]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:05.679]                   base::options(opts)
[17:26:05.679]                 }
[17:26:05.679]                 {
[17:26:05.679]                   {
[17:26:05.679]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:05.679]                     NULL
[17:26:05.679]                   }
[17:26:05.679]                   options(future.plan = NULL)
[17:26:05.679]                   if (is.na(NA_character_)) 
[17:26:05.679]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:05.679]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:05.679]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:05.679]                     .init = FALSE)
[17:26:05.679]                 }
[17:26:05.679]             }
[17:26:05.679]         }
[17:26:05.679]     })
[17:26:05.679]     if (TRUE) {
[17:26:05.679]         base::sink(type = "output", split = FALSE)
[17:26:05.679]         if (TRUE) {
[17:26:05.679]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:05.679]         }
[17:26:05.679]         else {
[17:26:05.679]             ...future.result["stdout"] <- base::list(NULL)
[17:26:05.679]         }
[17:26:05.679]         base::close(...future.stdout)
[17:26:05.679]         ...future.stdout <- NULL
[17:26:05.679]     }
[17:26:05.679]     ...future.result$conditions <- ...future.conditions
[17:26:05.679]     ...future.result$finished <- base::Sys.time()
[17:26:05.679]     ...future.result
[17:26:05.679] }
[17:26:05.687] Exporting 2 global objects (1.20 KiB) to cluster node #1 ...
[17:26:05.687] Exporting 'slow_fcn' (1.15 KiB) to cluster node #1 ...
[17:26:05.688] Exporting 'slow_fcn' (1.15 KiB) to cluster node #1 ... DONE
[17:26:05.688] Exporting 'x' (56 bytes) to cluster node #1 ...
[17:26:05.689] Exporting 'x' (56 bytes) to cluster node #1 ... DONE
[17:26:05.689] Exporting 2 global objects (1.20 KiB) to cluster node #1 ... DONE
[17:26:05.690] MultisessionFuture started
[17:26:05.691] - Launch lazy future ... done
[17:26:05.692] run() for 'MultisessionFuture' ... done
[17:26:05.693] getGlobalsAndPackages() ...
[17:26:05.693] Searching for globals...
[17:26:05.696] - globals found: [6] 'slow_fcn', 'x', '{', 'Sys.sleep', '+', '/'
[17:26:05.696] Searching for globals ... DONE
[17:26:05.696] Resolving globals: FALSE
[17:26:05.697] The total size of the 2 globals is 1.20 KiB (1232 bytes)
[17:26:05.697] The total size of the 2 globals exported for future expression ('slow_fcn(x)') is 1.20 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'slow_fcn' (1.15 KiB of class 'function') and 'x' (56 bytes of class 'numeric')
[17:26:05.698] - globals: [2] 'slow_fcn', 'x'
[17:26:05.698] 
[17:26:05.698] getGlobalsAndPackages() ... DONE
[17:26:05.699] run() for 'Future' ...
[17:26:05.699] - state: 'created'
[17:26:05.699] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:05.714] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:05.714] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:05.715]   - Field: 'node'
[17:26:05.715]   - Field: 'label'
[17:26:05.715]   - Field: 'local'
[17:26:05.715]   - Field: 'owner'
[17:26:05.715]   - Field: 'envir'
[17:26:05.716]   - Field: 'workers'
[17:26:05.716]   - Field: 'packages'
[17:26:05.716]   - Field: 'gc'
[17:26:05.716]   - Field: 'conditions'
[17:26:05.716]   - Field: 'persistent'
[17:26:05.716]   - Field: 'expr'
[17:26:05.717]   - Field: 'uuid'
[17:26:05.717]   - Field: 'seed'
[17:26:05.717]   - Field: 'version'
[17:26:05.717]   - Field: 'result'
[17:26:05.717]   - Field: 'asynchronous'
[17:26:05.717]   - Field: 'calls'
[17:26:05.718]   - Field: 'globals'
[17:26:05.718]   - Field: 'stdout'
[17:26:05.718]   - Field: 'earlySignal'
[17:26:05.718]   - Field: 'lazy'
[17:26:05.718]   - Field: 'state'
[17:26:05.719] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:05.719] - Launch lazy future ...
[17:26:05.719] Packages needed by the future expression (n = 0): <none>
[17:26:05.719] Packages needed by future strategies (n = 0): <none>
[17:26:05.720] {
[17:26:05.720]     {
[17:26:05.720]         {
[17:26:05.720]             ...future.startTime <- base::Sys.time()
[17:26:05.720]             {
[17:26:05.720]                 {
[17:26:05.720]                   {
[17:26:05.720]                     {
[17:26:05.720]                       base::local({
[17:26:05.720]                         has_future <- base::requireNamespace("future", 
[17:26:05.720]                           quietly = TRUE)
[17:26:05.720]                         if (has_future) {
[17:26:05.720]                           ns <- base::getNamespace("future")
[17:26:05.720]                           version <- ns[[".package"]][["version"]]
[17:26:05.720]                           if (is.null(version)) 
[17:26:05.720]                             version <- utils::packageVersion("future")
[17:26:05.720]                         }
[17:26:05.720]                         else {
[17:26:05.720]                           version <- NULL
[17:26:05.720]                         }
[17:26:05.720]                         if (!has_future || version < "1.8.0") {
[17:26:05.720]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:05.720]                             "", base::R.version$version.string), 
[17:26:05.720]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:05.720]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:05.720]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:05.720]                               "release", "version")], collapse = " "), 
[17:26:05.720]                             hostname = base::Sys.info()[["nodename"]])
[17:26:05.720]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:05.720]                             info)
[17:26:05.720]                           info <- base::paste(info, collapse = "; ")
[17:26:05.720]                           if (!has_future) {
[17:26:05.720]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:05.720]                               info)
[17:26:05.720]                           }
[17:26:05.720]                           else {
[17:26:05.720]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:05.720]                               info, version)
[17:26:05.720]                           }
[17:26:05.720]                           base::stop(msg)
[17:26:05.720]                         }
[17:26:05.720]                       })
[17:26:05.720]                     }
[17:26:05.720]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:05.720]                     base::options(mc.cores = 1L)
[17:26:05.720]                   }
[17:26:05.720]                   ...future.strategy.old <- future::plan("list")
[17:26:05.720]                   options(future.plan = NULL)
[17:26:05.720]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:05.720]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:05.720]                 }
[17:26:05.720]                 ...future.workdir <- getwd()
[17:26:05.720]             }
[17:26:05.720]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:05.720]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:05.720]         }
[17:26:05.720]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:05.720]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:05.720]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:05.720]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:05.720]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:05.720]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:05.720]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:05.720]             base::names(...future.oldOptions))
[17:26:05.720]     }
[17:26:05.720]     if (FALSE) {
[17:26:05.720]     }
[17:26:05.720]     else {
[17:26:05.720]         if (TRUE) {
[17:26:05.720]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:05.720]                 open = "w")
[17:26:05.720]         }
[17:26:05.720]         else {
[17:26:05.720]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:05.720]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:05.720]         }
[17:26:05.720]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:05.720]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:05.720]             base::sink(type = "output", split = FALSE)
[17:26:05.720]             base::close(...future.stdout)
[17:26:05.720]         }, add = TRUE)
[17:26:05.720]     }
[17:26:05.720]     ...future.frame <- base::sys.nframe()
[17:26:05.720]     ...future.conditions <- base::list()
[17:26:05.720]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:05.720]     if (FALSE) {
[17:26:05.720]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:05.720]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:05.720]     }
[17:26:05.720]     ...future.result <- base::tryCatch({
[17:26:05.720]         base::withCallingHandlers({
[17:26:05.720]             ...future.value <- base::withVisible(base::local({
[17:26:05.720]                 ...future.makeSendCondition <- base::local({
[17:26:05.720]                   sendCondition <- NULL
[17:26:05.720]                   function(frame = 1L) {
[17:26:05.720]                     if (is.function(sendCondition)) 
[17:26:05.720]                       return(sendCondition)
[17:26:05.720]                     ns <- getNamespace("parallel")
[17:26:05.720]                     if (exists("sendData", mode = "function", 
[17:26:05.720]                       envir = ns)) {
[17:26:05.720]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:05.720]                         envir = ns)
[17:26:05.720]                       envir <- sys.frame(frame)
[17:26:05.720]                       master <- NULL
[17:26:05.720]                       while (!identical(envir, .GlobalEnv) && 
[17:26:05.720]                         !identical(envir, emptyenv())) {
[17:26:05.720]                         if (exists("master", mode = "list", envir = envir, 
[17:26:05.720]                           inherits = FALSE)) {
[17:26:05.720]                           master <- get("master", mode = "list", 
[17:26:05.720]                             envir = envir, inherits = FALSE)
[17:26:05.720]                           if (inherits(master, c("SOCKnode", 
[17:26:05.720]                             "SOCK0node"))) {
[17:26:05.720]                             sendCondition <<- function(cond) {
[17:26:05.720]                               data <- list(type = "VALUE", value = cond, 
[17:26:05.720]                                 success = TRUE)
[17:26:05.720]                               parallel_sendData(master, data)
[17:26:05.720]                             }
[17:26:05.720]                             return(sendCondition)
[17:26:05.720]                           }
[17:26:05.720]                         }
[17:26:05.720]                         frame <- frame + 1L
[17:26:05.720]                         envir <- sys.frame(frame)
[17:26:05.720]                       }
[17:26:05.720]                     }
[17:26:05.720]                     sendCondition <<- function(cond) NULL
[17:26:05.720]                   }
[17:26:05.720]                 })
[17:26:05.720]                 withCallingHandlers({
[17:26:05.720]                   slow_fcn(x)
[17:26:05.720]                 }, immediateCondition = function(cond) {
[17:26:05.720]                   sendCondition <- ...future.makeSendCondition()
[17:26:05.720]                   sendCondition(cond)
[17:26:05.720]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:05.720]                   {
[17:26:05.720]                     inherits <- base::inherits
[17:26:05.720]                     invokeRestart <- base::invokeRestart
[17:26:05.720]                     is.null <- base::is.null
[17:26:05.720]                     muffled <- FALSE
[17:26:05.720]                     if (inherits(cond, "message")) {
[17:26:05.720]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:05.720]                       if (muffled) 
[17:26:05.720]                         invokeRestart("muffleMessage")
[17:26:05.720]                     }
[17:26:05.720]                     else if (inherits(cond, "warning")) {
[17:26:05.720]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:05.720]                       if (muffled) 
[17:26:05.720]                         invokeRestart("muffleWarning")
[17:26:05.720]                     }
[17:26:05.720]                     else if (inherits(cond, "condition")) {
[17:26:05.720]                       if (!is.null(pattern)) {
[17:26:05.720]                         computeRestarts <- base::computeRestarts
[17:26:05.720]                         grepl <- base::grepl
[17:26:05.720]                         restarts <- computeRestarts(cond)
[17:26:05.720]                         for (restart in restarts) {
[17:26:05.720]                           name <- restart$name
[17:26:05.720]                           if (is.null(name)) 
[17:26:05.720]                             next
[17:26:05.720]                           if (!grepl(pattern, name)) 
[17:26:05.720]                             next
[17:26:05.720]                           invokeRestart(restart)
[17:26:05.720]                           muffled <- TRUE
[17:26:05.720]                           break
[17:26:05.720]                         }
[17:26:05.720]                       }
[17:26:05.720]                     }
[17:26:05.720]                     invisible(muffled)
[17:26:05.720]                   }
[17:26:05.720]                   muffleCondition(cond)
[17:26:05.720]                 })
[17:26:05.720]             }))
[17:26:05.720]             future::FutureResult(value = ...future.value$value, 
[17:26:05.720]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:05.720]                   ...future.rng), globalenv = if (FALSE) 
[17:26:05.720]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:05.720]                     ...future.globalenv.names))
[17:26:05.720]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:05.720]         }, condition = base::local({
[17:26:05.720]             c <- base::c
[17:26:05.720]             inherits <- base::inherits
[17:26:05.720]             invokeRestart <- base::invokeRestart
[17:26:05.720]             length <- base::length
[17:26:05.720]             list <- base::list
[17:26:05.720]             seq.int <- base::seq.int
[17:26:05.720]             signalCondition <- base::signalCondition
[17:26:05.720]             sys.calls <- base::sys.calls
[17:26:05.720]             `[[` <- base::`[[`
[17:26:05.720]             `+` <- base::`+`
[17:26:05.720]             `<<-` <- base::`<<-`
[17:26:05.720]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:05.720]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:05.720]                   3L)]
[17:26:05.720]             }
[17:26:05.720]             function(cond) {
[17:26:05.720]                 is_error <- inherits(cond, "error")
[17:26:05.720]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:05.720]                   NULL)
[17:26:05.720]                 if (is_error) {
[17:26:05.720]                   sessionInformation <- function() {
[17:26:05.720]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:05.720]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:05.720]                       search = base::search(), system = base::Sys.info())
[17:26:05.720]                   }
[17:26:05.720]                   ...future.conditions[[length(...future.conditions) + 
[17:26:05.720]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:05.720]                     cond$call), session = sessionInformation(), 
[17:26:05.720]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:05.720]                   signalCondition(cond)
[17:26:05.720]                 }
[17:26:05.720]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:05.720]                 "immediateCondition"))) {
[17:26:05.720]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:05.720]                   ...future.conditions[[length(...future.conditions) + 
[17:26:05.720]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:05.720]                   if (TRUE && !signal) {
[17:26:05.720]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:05.720]                     {
[17:26:05.720]                       inherits <- base::inherits
[17:26:05.720]                       invokeRestart <- base::invokeRestart
[17:26:05.720]                       is.null <- base::is.null
[17:26:05.720]                       muffled <- FALSE
[17:26:05.720]                       if (inherits(cond, "message")) {
[17:26:05.720]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:05.720]                         if (muffled) 
[17:26:05.720]                           invokeRestart("muffleMessage")
[17:26:05.720]                       }
[17:26:05.720]                       else if (inherits(cond, "warning")) {
[17:26:05.720]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:05.720]                         if (muffled) 
[17:26:05.720]                           invokeRestart("muffleWarning")
[17:26:05.720]                       }
[17:26:05.720]                       else if (inherits(cond, "condition")) {
[17:26:05.720]                         if (!is.null(pattern)) {
[17:26:05.720]                           computeRestarts <- base::computeRestarts
[17:26:05.720]                           grepl <- base::grepl
[17:26:05.720]                           restarts <- computeRestarts(cond)
[17:26:05.720]                           for (restart in restarts) {
[17:26:05.720]                             name <- restart$name
[17:26:05.720]                             if (is.null(name)) 
[17:26:05.720]                               next
[17:26:05.720]                             if (!grepl(pattern, name)) 
[17:26:05.720]                               next
[17:26:05.720]                             invokeRestart(restart)
[17:26:05.720]                             muffled <- TRUE
[17:26:05.720]                             break
[17:26:05.720]                           }
[17:26:05.720]                         }
[17:26:05.720]                       }
[17:26:05.720]                       invisible(muffled)
[17:26:05.720]                     }
[17:26:05.720]                     muffleCondition(cond, pattern = "^muffle")
[17:26:05.720]                   }
[17:26:05.720]                 }
[17:26:05.720]                 else {
[17:26:05.720]                   if (TRUE) {
[17:26:05.720]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:05.720]                     {
[17:26:05.720]                       inherits <- base::inherits
[17:26:05.720]                       invokeRestart <- base::invokeRestart
[17:26:05.720]                       is.null <- base::is.null
[17:26:05.720]                       muffled <- FALSE
[17:26:05.720]                       if (inherits(cond, "message")) {
[17:26:05.720]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:05.720]                         if (muffled) 
[17:26:05.720]                           invokeRestart("muffleMessage")
[17:26:05.720]                       }
[17:26:05.720]                       else if (inherits(cond, "warning")) {
[17:26:05.720]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:05.720]                         if (muffled) 
[17:26:05.720]                           invokeRestart("muffleWarning")
[17:26:05.720]                       }
[17:26:05.720]                       else if (inherits(cond, "condition")) {
[17:26:05.720]                         if (!is.null(pattern)) {
[17:26:05.720]                           computeRestarts <- base::computeRestarts
[17:26:05.720]                           grepl <- base::grepl
[17:26:05.720]                           restarts <- computeRestarts(cond)
[17:26:05.720]                           for (restart in restarts) {
[17:26:05.720]                             name <- restart$name
[17:26:05.720]                             if (is.null(name)) 
[17:26:05.720]                               next
[17:26:05.720]                             if (!grepl(pattern, name)) 
[17:26:05.720]                               next
[17:26:05.720]                             invokeRestart(restart)
[17:26:05.720]                             muffled <- TRUE
[17:26:05.720]                             break
[17:26:05.720]                           }
[17:26:05.720]                         }
[17:26:05.720]                       }
[17:26:05.720]                       invisible(muffled)
[17:26:05.720]                     }
[17:26:05.720]                     muffleCondition(cond, pattern = "^muffle")
[17:26:05.720]                   }
[17:26:05.720]                 }
[17:26:05.720]             }
[17:26:05.720]         }))
[17:26:05.720]     }, error = function(ex) {
[17:26:05.720]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:05.720]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:05.720]                 ...future.rng), started = ...future.startTime, 
[17:26:05.720]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:05.720]             version = "1.8"), class = "FutureResult")
[17:26:05.720]     }, finally = {
[17:26:05.720]         if (!identical(...future.workdir, getwd())) 
[17:26:05.720]             setwd(...future.workdir)
[17:26:05.720]         {
[17:26:05.720]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:05.720]                 ...future.oldOptions$nwarnings <- NULL
[17:26:05.720]             }
[17:26:05.720]             base::options(...future.oldOptions)
[17:26:05.720]             if (.Platform$OS.type == "windows") {
[17:26:05.720]                 old_names <- names(...future.oldEnvVars)
[17:26:05.720]                 envs <- base::Sys.getenv()
[17:26:05.720]                 names <- names(envs)
[17:26:05.720]                 common <- intersect(names, old_names)
[17:26:05.720]                 added <- setdiff(names, old_names)
[17:26:05.720]                 removed <- setdiff(old_names, names)
[17:26:05.720]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:05.720]                   envs[common]]
[17:26:05.720]                 NAMES <- toupper(changed)
[17:26:05.720]                 args <- list()
[17:26:05.720]                 for (kk in seq_along(NAMES)) {
[17:26:05.720]                   name <- changed[[kk]]
[17:26:05.720]                   NAME <- NAMES[[kk]]
[17:26:05.720]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:05.720]                     next
[17:26:05.720]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:05.720]                 }
[17:26:05.720]                 NAMES <- toupper(added)
[17:26:05.720]                 for (kk in seq_along(NAMES)) {
[17:26:05.720]                   name <- added[[kk]]
[17:26:05.720]                   NAME <- NAMES[[kk]]
[17:26:05.720]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:05.720]                     next
[17:26:05.720]                   args[[name]] <- ""
[17:26:05.720]                 }
[17:26:05.720]                 NAMES <- toupper(removed)
[17:26:05.720]                 for (kk in seq_along(NAMES)) {
[17:26:05.720]                   name <- removed[[kk]]
[17:26:05.720]                   NAME <- NAMES[[kk]]
[17:26:05.720]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:05.720]                     next
[17:26:05.720]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:05.720]                 }
[17:26:05.720]                 if (length(args) > 0) 
[17:26:05.720]                   base::do.call(base::Sys.setenv, args = args)
[17:26:05.720]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:05.720]             }
[17:26:05.720]             else {
[17:26:05.720]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:05.720]             }
[17:26:05.720]             {
[17:26:05.720]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:05.720]                   0L) {
[17:26:05.720]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:05.720]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:05.720]                   base::options(opts)
[17:26:05.720]                 }
[17:26:05.720]                 {
[17:26:05.720]                   {
[17:26:05.720]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:05.720]                     NULL
[17:26:05.720]                   }
[17:26:05.720]                   options(future.plan = NULL)
[17:26:05.720]                   if (is.na(NA_character_)) 
[17:26:05.720]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:05.720]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:05.720]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:05.720]                     .init = FALSE)
[17:26:05.720]                 }
[17:26:05.720]             }
[17:26:05.720]         }
[17:26:05.720]     })
[17:26:05.720]     if (TRUE) {
[17:26:05.720]         base::sink(type = "output", split = FALSE)
[17:26:05.720]         if (TRUE) {
[17:26:05.720]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:05.720]         }
[17:26:05.720]         else {
[17:26:05.720]             ...future.result["stdout"] <- base::list(NULL)
[17:26:05.720]         }
[17:26:05.720]         base::close(...future.stdout)
[17:26:05.720]         ...future.stdout <- NULL
[17:26:05.720]     }
[17:26:05.720]     ...future.result$conditions <- ...future.conditions
[17:26:05.720]     ...future.result$finished <- base::Sys.time()
[17:26:05.720]     ...future.result
[17:26:05.720] }
[17:26:05.805] Exporting 2 global objects (1.20 KiB) to cluster node #2 ...
[17:26:05.805] Exporting 'slow_fcn' (1.15 KiB) to cluster node #2 ...
[17:26:05.805] Exporting 'slow_fcn' (1.15 KiB) to cluster node #2 ... DONE
[17:26:05.806] Exporting 'x' (56 bytes) to cluster node #2 ...
[17:26:05.806] Exporting 'x' (56 bytes) to cluster node #2 ... DONE
[17:26:05.806] Exporting 2 global objects (1.20 KiB) to cluster node #2 ... DONE
[17:26:05.808] MultisessionFuture started
[17:26:05.808] - Launch lazy future ... done
[17:26:05.809] run() for 'MultisessionFuture' ... done
[17:26:05.809] getGlobalsAndPackages() ...
[17:26:05.809] Searching for globals...
[17:26:05.811] - globals found: [6] 'slow_fcn', 'x', '{', 'Sys.sleep', '+', '/'
[17:26:05.811] Searching for globals ... DONE
[17:26:05.811] Resolving globals: FALSE
[17:26:05.812] The total size of the 2 globals is 1.20 KiB (1232 bytes)
[17:26:05.812] The total size of the 2 globals exported for future expression ('slow_fcn(x)') is 1.20 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'slow_fcn' (1.15 KiB of class 'function') and 'x' (56 bytes of class 'numeric')
[17:26:05.812] - globals: [2] 'slow_fcn', 'x'
[17:26:05.813] 
[17:26:05.813] getGlobalsAndPackages() ... DONE
[17:26:05.814] run() for 'Future' ...
[17:26:05.814] - state: 'created'
[17:26:05.814] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:05.826] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:05.826] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:05.826]   - Field: 'node'
[17:26:05.827]   - Field: 'label'
[17:26:05.827]   - Field: 'local'
[17:26:05.827]   - Field: 'owner'
[17:26:05.827]   - Field: 'envir'
[17:26:05.827]   - Field: 'workers'
[17:26:05.827]   - Field: 'packages'
[17:26:05.828]   - Field: 'gc'
[17:26:05.828]   - Field: 'conditions'
[17:26:05.828]   - Field: 'persistent'
[17:26:05.828]   - Field: 'expr'
[17:26:05.828]   - Field: 'uuid'
[17:26:05.828]   - Field: 'seed'
[17:26:05.829]   - Field: 'version'
[17:26:05.829]   - Field: 'result'
[17:26:05.829]   - Field: 'asynchronous'
[17:26:05.829]   - Field: 'calls'
[17:26:05.829]   - Field: 'globals'
[17:26:05.829]   - Field: 'stdout'
[17:26:05.830]   - Field: 'earlySignal'
[17:26:05.830]   - Field: 'lazy'
[17:26:05.830]   - Field: 'state'
[17:26:05.830] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:05.830] - Launch lazy future ...
[17:26:05.831] Packages needed by the future expression (n = 0): <none>
[17:26:05.831] Packages needed by future strategies (n = 0): <none>
[17:26:05.831] {
[17:26:05.831]     {
[17:26:05.831]         {
[17:26:05.831]             ...future.startTime <- base::Sys.time()
[17:26:05.831]             {
[17:26:05.831]                 {
[17:26:05.831]                   {
[17:26:05.831]                     {
[17:26:05.831]                       base::local({
[17:26:05.831]                         has_future <- base::requireNamespace("future", 
[17:26:05.831]                           quietly = TRUE)
[17:26:05.831]                         if (has_future) {
[17:26:05.831]                           ns <- base::getNamespace("future")
[17:26:05.831]                           version <- ns[[".package"]][["version"]]
[17:26:05.831]                           if (is.null(version)) 
[17:26:05.831]                             version <- utils::packageVersion("future")
[17:26:05.831]                         }
[17:26:05.831]                         else {
[17:26:05.831]                           version <- NULL
[17:26:05.831]                         }
[17:26:05.831]                         if (!has_future || version < "1.8.0") {
[17:26:05.831]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:05.831]                             "", base::R.version$version.string), 
[17:26:05.831]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:05.831]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:05.831]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:05.831]                               "release", "version")], collapse = " "), 
[17:26:05.831]                             hostname = base::Sys.info()[["nodename"]])
[17:26:05.831]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:05.831]                             info)
[17:26:05.831]                           info <- base::paste(info, collapse = "; ")
[17:26:05.831]                           if (!has_future) {
[17:26:05.831]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:05.831]                               info)
[17:26:05.831]                           }
[17:26:05.831]                           else {
[17:26:05.831]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:05.831]                               info, version)
[17:26:05.831]                           }
[17:26:05.831]                           base::stop(msg)
[17:26:05.831]                         }
[17:26:05.831]                       })
[17:26:05.831]                     }
[17:26:05.831]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:05.831]                     base::options(mc.cores = 1L)
[17:26:05.831]                   }
[17:26:05.831]                   ...future.strategy.old <- future::plan("list")
[17:26:05.831]                   options(future.plan = NULL)
[17:26:05.831]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:05.831]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:05.831]                 }
[17:26:05.831]                 ...future.workdir <- getwd()
[17:26:05.831]             }
[17:26:05.831]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:05.831]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:05.831]         }
[17:26:05.831]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:05.831]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:05.831]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:05.831]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:05.831]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:05.831]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:05.831]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:05.831]             base::names(...future.oldOptions))
[17:26:05.831]     }
[17:26:05.831]     if (FALSE) {
[17:26:05.831]     }
[17:26:05.831]     else {
[17:26:05.831]         if (TRUE) {
[17:26:05.831]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:05.831]                 open = "w")
[17:26:05.831]         }
[17:26:05.831]         else {
[17:26:05.831]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:05.831]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:05.831]         }
[17:26:05.831]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:05.831]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:05.831]             base::sink(type = "output", split = FALSE)
[17:26:05.831]             base::close(...future.stdout)
[17:26:05.831]         }, add = TRUE)
[17:26:05.831]     }
[17:26:05.831]     ...future.frame <- base::sys.nframe()
[17:26:05.831]     ...future.conditions <- base::list()
[17:26:05.831]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:05.831]     if (FALSE) {
[17:26:05.831]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:05.831]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:05.831]     }
[17:26:05.831]     ...future.result <- base::tryCatch({
[17:26:05.831]         base::withCallingHandlers({
[17:26:05.831]             ...future.value <- base::withVisible(base::local({
[17:26:05.831]                 ...future.makeSendCondition <- base::local({
[17:26:05.831]                   sendCondition <- NULL
[17:26:05.831]                   function(frame = 1L) {
[17:26:05.831]                     if (is.function(sendCondition)) 
[17:26:05.831]                       return(sendCondition)
[17:26:05.831]                     ns <- getNamespace("parallel")
[17:26:05.831]                     if (exists("sendData", mode = "function", 
[17:26:05.831]                       envir = ns)) {
[17:26:05.831]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:05.831]                         envir = ns)
[17:26:05.831]                       envir <- sys.frame(frame)
[17:26:05.831]                       master <- NULL
[17:26:05.831]                       while (!identical(envir, .GlobalEnv) && 
[17:26:05.831]                         !identical(envir, emptyenv())) {
[17:26:05.831]                         if (exists("master", mode = "list", envir = envir, 
[17:26:05.831]                           inherits = FALSE)) {
[17:26:05.831]                           master <- get("master", mode = "list", 
[17:26:05.831]                             envir = envir, inherits = FALSE)
[17:26:05.831]                           if (inherits(master, c("SOCKnode", 
[17:26:05.831]                             "SOCK0node"))) {
[17:26:05.831]                             sendCondition <<- function(cond) {
[17:26:05.831]                               data <- list(type = "VALUE", value = cond, 
[17:26:05.831]                                 success = TRUE)
[17:26:05.831]                               parallel_sendData(master, data)
[17:26:05.831]                             }
[17:26:05.831]                             return(sendCondition)
[17:26:05.831]                           }
[17:26:05.831]                         }
[17:26:05.831]                         frame <- frame + 1L
[17:26:05.831]                         envir <- sys.frame(frame)
[17:26:05.831]                       }
[17:26:05.831]                     }
[17:26:05.831]                     sendCondition <<- function(cond) NULL
[17:26:05.831]                   }
[17:26:05.831]                 })
[17:26:05.831]                 withCallingHandlers({
[17:26:05.831]                   slow_fcn(x)
[17:26:05.831]                 }, immediateCondition = function(cond) {
[17:26:05.831]                   sendCondition <- ...future.makeSendCondition()
[17:26:05.831]                   sendCondition(cond)
[17:26:05.831]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:05.831]                   {
[17:26:05.831]                     inherits <- base::inherits
[17:26:05.831]                     invokeRestart <- base::invokeRestart
[17:26:05.831]                     is.null <- base::is.null
[17:26:05.831]                     muffled <- FALSE
[17:26:05.831]                     if (inherits(cond, "message")) {
[17:26:05.831]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:05.831]                       if (muffled) 
[17:26:05.831]                         invokeRestart("muffleMessage")
[17:26:05.831]                     }
[17:26:05.831]                     else if (inherits(cond, "warning")) {
[17:26:05.831]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:05.831]                       if (muffled) 
[17:26:05.831]                         invokeRestart("muffleWarning")
[17:26:05.831]                     }
[17:26:05.831]                     else if (inherits(cond, "condition")) {
[17:26:05.831]                       if (!is.null(pattern)) {
[17:26:05.831]                         computeRestarts <- base::computeRestarts
[17:26:05.831]                         grepl <- base::grepl
[17:26:05.831]                         restarts <- computeRestarts(cond)
[17:26:05.831]                         for (restart in restarts) {
[17:26:05.831]                           name <- restart$name
[17:26:05.831]                           if (is.null(name)) 
[17:26:05.831]                             next
[17:26:05.831]                           if (!grepl(pattern, name)) 
[17:26:05.831]                             next
[17:26:05.831]                           invokeRestart(restart)
[17:26:05.831]                           muffled <- TRUE
[17:26:05.831]                           break
[17:26:05.831]                         }
[17:26:05.831]                       }
[17:26:05.831]                     }
[17:26:05.831]                     invisible(muffled)
[17:26:05.831]                   }
[17:26:05.831]                   muffleCondition(cond)
[17:26:05.831]                 })
[17:26:05.831]             }))
[17:26:05.831]             future::FutureResult(value = ...future.value$value, 
[17:26:05.831]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:05.831]                   ...future.rng), globalenv = if (FALSE) 
[17:26:05.831]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:05.831]                     ...future.globalenv.names))
[17:26:05.831]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:05.831]         }, condition = base::local({
[17:26:05.831]             c <- base::c
[17:26:05.831]             inherits <- base::inherits
[17:26:05.831]             invokeRestart <- base::invokeRestart
[17:26:05.831]             length <- base::length
[17:26:05.831]             list <- base::list
[17:26:05.831]             seq.int <- base::seq.int
[17:26:05.831]             signalCondition <- base::signalCondition
[17:26:05.831]             sys.calls <- base::sys.calls
[17:26:05.831]             `[[` <- base::`[[`
[17:26:05.831]             `+` <- base::`+`
[17:26:05.831]             `<<-` <- base::`<<-`
[17:26:05.831]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:05.831]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:05.831]                   3L)]
[17:26:05.831]             }
[17:26:05.831]             function(cond) {
[17:26:05.831]                 is_error <- inherits(cond, "error")
[17:26:05.831]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:05.831]                   NULL)
[17:26:05.831]                 if (is_error) {
[17:26:05.831]                   sessionInformation <- function() {
[17:26:05.831]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:05.831]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:05.831]                       search = base::search(), system = base::Sys.info())
[17:26:05.831]                   }
[17:26:05.831]                   ...future.conditions[[length(...future.conditions) + 
[17:26:05.831]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:05.831]                     cond$call), session = sessionInformation(), 
[17:26:05.831]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:05.831]                   signalCondition(cond)
[17:26:05.831]                 }
[17:26:05.831]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:05.831]                 "immediateCondition"))) {
[17:26:05.831]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:05.831]                   ...future.conditions[[length(...future.conditions) + 
[17:26:05.831]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:05.831]                   if (TRUE && !signal) {
[17:26:05.831]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:05.831]                     {
[17:26:05.831]                       inherits <- base::inherits
[17:26:05.831]                       invokeRestart <- base::invokeRestart
[17:26:05.831]                       is.null <- base::is.null
[17:26:05.831]                       muffled <- FALSE
[17:26:05.831]                       if (inherits(cond, "message")) {
[17:26:05.831]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:05.831]                         if (muffled) 
[17:26:05.831]                           invokeRestart("muffleMessage")
[17:26:05.831]                       }
[17:26:05.831]                       else if (inherits(cond, "warning")) {
[17:26:05.831]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:05.831]                         if (muffled) 
[17:26:05.831]                           invokeRestart("muffleWarning")
[17:26:05.831]                       }
[17:26:05.831]                       else if (inherits(cond, "condition")) {
[17:26:05.831]                         if (!is.null(pattern)) {
[17:26:05.831]                           computeRestarts <- base::computeRestarts
[17:26:05.831]                           grepl <- base::grepl
[17:26:05.831]                           restarts <- computeRestarts(cond)
[17:26:05.831]                           for (restart in restarts) {
[17:26:05.831]                             name <- restart$name
[17:26:05.831]                             if (is.null(name)) 
[17:26:05.831]                               next
[17:26:05.831]                             if (!grepl(pattern, name)) 
[17:26:05.831]                               next
[17:26:05.831]                             invokeRestart(restart)
[17:26:05.831]                             muffled <- TRUE
[17:26:05.831]                             break
[17:26:05.831]                           }
[17:26:05.831]                         }
[17:26:05.831]                       }
[17:26:05.831]                       invisible(muffled)
[17:26:05.831]                     }
[17:26:05.831]                     muffleCondition(cond, pattern = "^muffle")
[17:26:05.831]                   }
[17:26:05.831]                 }
[17:26:05.831]                 else {
[17:26:05.831]                   if (TRUE) {
[17:26:05.831]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:05.831]                     {
[17:26:05.831]                       inherits <- base::inherits
[17:26:05.831]                       invokeRestart <- base::invokeRestart
[17:26:05.831]                       is.null <- base::is.null
[17:26:05.831]                       muffled <- FALSE
[17:26:05.831]                       if (inherits(cond, "message")) {
[17:26:05.831]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:05.831]                         if (muffled) 
[17:26:05.831]                           invokeRestart("muffleMessage")
[17:26:05.831]                       }
[17:26:05.831]                       else if (inherits(cond, "warning")) {
[17:26:05.831]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:05.831]                         if (muffled) 
[17:26:05.831]                           invokeRestart("muffleWarning")
[17:26:05.831]                       }
[17:26:05.831]                       else if (inherits(cond, "condition")) {
[17:26:05.831]                         if (!is.null(pattern)) {
[17:26:05.831]                           computeRestarts <- base::computeRestarts
[17:26:05.831]                           grepl <- base::grepl
[17:26:05.831]                           restarts <- computeRestarts(cond)
[17:26:05.831]                           for (restart in restarts) {
[17:26:05.831]                             name <- restart$name
[17:26:05.831]                             if (is.null(name)) 
[17:26:05.831]                               next
[17:26:05.831]                             if (!grepl(pattern, name)) 
[17:26:05.831]                               next
[17:26:05.831]                             invokeRestart(restart)
[17:26:05.831]                             muffled <- TRUE
[17:26:05.831]                             break
[17:26:05.831]                           }
[17:26:05.831]                         }
[17:26:05.831]                       }
[17:26:05.831]                       invisible(muffled)
[17:26:05.831]                     }
[17:26:05.831]                     muffleCondition(cond, pattern = "^muffle")
[17:26:05.831]                   }
[17:26:05.831]                 }
[17:26:05.831]             }
[17:26:05.831]         }))
[17:26:05.831]     }, error = function(ex) {
[17:26:05.831]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:05.831]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:05.831]                 ...future.rng), started = ...future.startTime, 
[17:26:05.831]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:05.831]             version = "1.8"), class = "FutureResult")
[17:26:05.831]     }, finally = {
[17:26:05.831]         if (!identical(...future.workdir, getwd())) 
[17:26:05.831]             setwd(...future.workdir)
[17:26:05.831]         {
[17:26:05.831]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:05.831]                 ...future.oldOptions$nwarnings <- NULL
[17:26:05.831]             }
[17:26:05.831]             base::options(...future.oldOptions)
[17:26:05.831]             if (.Platform$OS.type == "windows") {
[17:26:05.831]                 old_names <- names(...future.oldEnvVars)
[17:26:05.831]                 envs <- base::Sys.getenv()
[17:26:05.831]                 names <- names(envs)
[17:26:05.831]                 common <- intersect(names, old_names)
[17:26:05.831]                 added <- setdiff(names, old_names)
[17:26:05.831]                 removed <- setdiff(old_names, names)
[17:26:05.831]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:05.831]                   envs[common]]
[17:26:05.831]                 NAMES <- toupper(changed)
[17:26:05.831]                 args <- list()
[17:26:05.831]                 for (kk in seq_along(NAMES)) {
[17:26:05.831]                   name <- changed[[kk]]
[17:26:05.831]                   NAME <- NAMES[[kk]]
[17:26:05.831]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:05.831]                     next
[17:26:05.831]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:05.831]                 }
[17:26:05.831]                 NAMES <- toupper(added)
[17:26:05.831]                 for (kk in seq_along(NAMES)) {
[17:26:05.831]                   name <- added[[kk]]
[17:26:05.831]                   NAME <- NAMES[[kk]]
[17:26:05.831]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:05.831]                     next
[17:26:05.831]                   args[[name]] <- ""
[17:26:05.831]                 }
[17:26:05.831]                 NAMES <- toupper(removed)
[17:26:05.831]                 for (kk in seq_along(NAMES)) {
[17:26:05.831]                   name <- removed[[kk]]
[17:26:05.831]                   NAME <- NAMES[[kk]]
[17:26:05.831]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:05.831]                     next
[17:26:05.831]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:05.831]                 }
[17:26:05.831]                 if (length(args) > 0) 
[17:26:05.831]                   base::do.call(base::Sys.setenv, args = args)
[17:26:05.831]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:05.831]             }
[17:26:05.831]             else {
[17:26:05.831]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:05.831]             }
[17:26:05.831]             {
[17:26:05.831]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:05.831]                   0L) {
[17:26:05.831]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:05.831]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:05.831]                   base::options(opts)
[17:26:05.831]                 }
[17:26:05.831]                 {
[17:26:05.831]                   {
[17:26:05.831]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:05.831]                     NULL
[17:26:05.831]                   }
[17:26:05.831]                   options(future.plan = NULL)
[17:26:05.831]                   if (is.na(NA_character_)) 
[17:26:05.831]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:05.831]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:05.831]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:05.831]                     .init = FALSE)
[17:26:05.831]                 }
[17:26:05.831]             }
[17:26:05.831]         }
[17:26:05.831]     })
[17:26:05.831]     if (TRUE) {
[17:26:05.831]         base::sink(type = "output", split = FALSE)
[17:26:05.831]         if (TRUE) {
[17:26:05.831]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:05.831]         }
[17:26:05.831]         else {
[17:26:05.831]             ...future.result["stdout"] <- base::list(NULL)
[17:26:05.831]         }
[17:26:05.831]         base::close(...future.stdout)
[17:26:05.831]         ...future.stdout <- NULL
[17:26:05.831]     }
[17:26:05.831]     ...future.result$conditions <- ...future.conditions
[17:26:05.831]     ...future.result$finished <- base::Sys.time()
[17:26:05.831]     ...future.result
[17:26:05.831] }
[17:26:05.836] Poll #1 (0): usedNodes() = 2, workers = 2
[17:26:06.255] Poll #2 (0.42 secs): usedNodes() = 2, workers = 2
[17:26:06.684] Poll #3 (0.85 secs): usedNodes() = 2, workers = 2
[17:26:06.700] receiveMessageFromWorker() for ClusterFuture ...
[17:26:06.700] - Validating connection of MultisessionFuture
[17:26:06.701] - received message: FutureResult
[17:26:06.702] - Received FutureResult
[17:26:06.702] - Erased future from FutureRegistry
[17:26:06.702] result() for ClusterFuture ...
[17:26:06.702] - result already collected: FutureResult
[17:26:06.703] result() for ClusterFuture ... done
[17:26:06.706] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:06.706] result() for ClusterFuture ...
[17:26:06.707] - result already collected: FutureResult
[17:26:06.707] result() for ClusterFuture ... done
[17:26:06.707] result() for ClusterFuture ...
[17:26:06.707] - result already collected: FutureResult
[17:26:06.707] result() for ClusterFuture ... done
[17:26:06.710] Exporting 2 global objects (1.20 KiB) to cluster node #1 ...
[17:26:06.710] Exporting 'slow_fcn' (1.15 KiB) to cluster node #1 ...
[17:26:06.711] Exporting 'slow_fcn' (1.15 KiB) to cluster node #1 ... DONE
[17:26:06.711] Exporting 'x' (56 bytes) to cluster node #1 ...
[17:26:06.711] Exporting 'x' (56 bytes) to cluster node #1 ... DONE
[17:26:06.711] Exporting 2 global objects (1.20 KiB) to cluster node #1 ... DONE
[17:26:06.713] MultisessionFuture started
[17:26:06.714] - Launch lazy future ... done
[17:26:06.714] run() for 'MultisessionFuture' ... done
[17:26:06.714] resolve() on list ...
[17:26:06.715]  recursive: 0
[17:26:06.715]  length: 3
[17:26:06.715] 
[17:26:06.715] Future #1
[17:26:06.715] result() for ClusterFuture ...
[17:26:06.716] - result already collected: FutureResult
[17:26:06.716] result() for ClusterFuture ... done
[17:26:06.716] result() for ClusterFuture ...
[17:26:06.716] - result already collected: FutureResult
[17:26:06.716] result() for ClusterFuture ... done
[17:26:06.716] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:26:06.717] - nx: 3
[17:26:06.717] - relay: TRUE
[17:26:06.717] - stdout: TRUE
[17:26:06.717] - signal: TRUE
[17:26:06.717] - resignal: FALSE
[17:26:06.717] - force: TRUE
[17:26:06.718] - relayed: [n=3] FALSE, FALSE, FALSE
[17:26:06.718] - queued futures: [n=3] FALSE, FALSE, FALSE
[17:26:06.718]  - until=1
[17:26:06.718]  - relaying element #1
[17:26:06.718] result() for ClusterFuture ...
[17:26:06.718] - result already collected: FutureResult
[17:26:06.719] result() for ClusterFuture ... done
[17:26:06.719] result() for ClusterFuture ...
[17:26:06.719] - result already collected: FutureResult
[17:26:06.719] result() for ClusterFuture ... done
[17:26:06.719] result() for ClusterFuture ...
[17:26:06.719] - result already collected: FutureResult
[17:26:06.720] result() for ClusterFuture ... done
[17:26:06.720] result() for ClusterFuture ...
[17:26:06.720] - result already collected: FutureResult
[17:26:06.720] result() for ClusterFuture ... done
[17:26:06.720] - relayed: [n=3] TRUE, FALSE, FALSE
[17:26:06.720] - queued futures: [n=3] TRUE, FALSE, FALSE
[17:26:06.721] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[17:26:06.721]  length: 2 (resolved future 1)
[17:26:06.871] receiveMessageFromWorker() for ClusterFuture ...
[17:26:06.872] - Validating connection of MultisessionFuture
[17:26:06.872] - received message: FutureResult
[17:26:06.873] - Received FutureResult
[17:26:06.873] - Erased future from FutureRegistry
[17:26:06.873] result() for ClusterFuture ...
[17:26:06.873] - result already collected: FutureResult
[17:26:06.874] result() for ClusterFuture ... done
[17:26:06.876] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:06.876] Future #2
[17:26:06.876] result() for ClusterFuture ...
[17:26:06.876] - result already collected: FutureResult
[17:26:06.877] result() for ClusterFuture ... done
[17:26:06.877] result() for ClusterFuture ...
[17:26:06.877] - result already collected: FutureResult
[17:26:06.877] result() for ClusterFuture ... done
[17:26:06.877] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:26:06.877] - nx: 3
[17:26:06.878] - relay: TRUE
[17:26:06.878] - stdout: TRUE
[17:26:06.878] - signal: TRUE
[17:26:06.878] - resignal: FALSE
[17:26:06.878] - force: TRUE
[17:26:06.878] - relayed: [n=3] TRUE, FALSE, FALSE
[17:26:06.879] - queued futures: [n=3] TRUE, FALSE, FALSE
[17:26:06.879]  - until=2
[17:26:06.879]  - relaying element #2
[17:26:06.879] result() for ClusterFuture ...
[17:26:06.879] - result already collected: FutureResult
[17:26:06.879] result() for ClusterFuture ... done
[17:26:06.880] result() for ClusterFuture ...
[17:26:06.880] - result already collected: FutureResult
[17:26:06.880] result() for ClusterFuture ... done
[17:26:06.880] result() for ClusterFuture ...
[17:26:06.880] - result already collected: FutureResult
[17:26:06.880] result() for ClusterFuture ... done
[17:26:06.881] result() for ClusterFuture ...
[17:26:06.881] - result already collected: FutureResult
[17:26:06.881] result() for ClusterFuture ... done
[17:26:06.881] - relayed: [n=3] TRUE, TRUE, FALSE
[17:26:06.881] - queued futures: [n=3] TRUE, TRUE, FALSE
[17:26:06.881] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:26:06.882]  length: 1 (resolved future 2)
[17:26:08.234] receiveMessageFromWorker() for ClusterFuture ...
[17:26:08.235] - Validating connection of MultisessionFuture
[17:26:08.235] - received message: FutureResult
[17:26:08.236] - Received FutureResult
[17:26:08.238] - Erased future from FutureRegistry
[17:26:08.238] result() for ClusterFuture ...
[17:26:08.238] - result already collected: FutureResult
[17:26:08.238] result() for ClusterFuture ... done
[17:26:08.241] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:08.241] Future #3
[17:26:08.241] result() for ClusterFuture ...
[17:26:08.241] - result already collected: FutureResult
[17:26:08.241] result() for ClusterFuture ... done
[17:26:08.242] result() for ClusterFuture ...
[17:26:08.242] - result already collected: FutureResult
[17:26:08.242] result() for ClusterFuture ... done
[17:26:08.242] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:26:08.242] - nx: 3
[17:26:08.242] - relay: TRUE
[17:26:08.243] - stdout: TRUE
[17:26:08.243] - signal: TRUE
[17:26:08.243] - resignal: FALSE
[17:26:08.243] - force: TRUE
[17:26:08.243] - relayed: [n=3] TRUE, TRUE, FALSE
[17:26:08.243] - queued futures: [n=3] TRUE, TRUE, FALSE
[17:26:08.244]  - until=3
[17:26:08.244]  - relaying element #3
[17:26:08.244] result() for ClusterFuture ...
[17:26:08.244] - result already collected: FutureResult
[17:26:08.244] result() for ClusterFuture ... done
[17:26:08.244] result() for ClusterFuture ...
[17:26:08.244] - result already collected: FutureResult
[17:26:08.245] result() for ClusterFuture ... done
[17:26:08.245] result() for ClusterFuture ...
[17:26:08.245] - result already collected: FutureResult
[17:26:08.245] result() for ClusterFuture ... done
[17:26:08.245] result() for ClusterFuture ...
[17:26:08.245] - result already collected: FutureResult
[17:26:08.246] result() for ClusterFuture ... done
[17:26:08.246] - relayed: [n=3] TRUE, TRUE, TRUE
[17:26:08.246] - queued futures: [n=3] TRUE, TRUE, TRUE
[17:26:08.246] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:26:08.246]  length: 0 (resolved future 3)
[17:26:08.246] Relaying remaining futures
[17:26:08.247] signalConditionsASAP(NULL, pos=0) ...
[17:26:08.247] - nx: 3
[17:26:08.247] - relay: TRUE
[17:26:08.247] - stdout: TRUE
[17:26:08.247] - signal: TRUE
[17:26:08.247] - resignal: FALSE
[17:26:08.247] - force: TRUE
[17:26:08.248] - relayed: [n=3] TRUE, TRUE, TRUE
[17:26:08.248] - queued futures: [n=3] TRUE, TRUE, TRUE
 - flush all
[17:26:08.248] - relayed: [n=3] TRUE, TRUE, TRUE
[17:26:08.248] - queued futures: [n=3] TRUE, TRUE, TRUE
[17:26:08.248] signalConditionsASAP(NULL, pos=0) ... done
[17:26:08.248] resolve() on list ... DONE
[17:26:08.249] result() for ClusterFuture ...
[17:26:08.249] - result already collected: FutureResult
[17:26:08.249] result() for ClusterFuture ... done
[17:26:08.249] result() for ClusterFuture ...
[17:26:08.249] - result already collected: FutureResult
[17:26:08.249] result() for ClusterFuture ... done
[17:26:08.250] result() for ClusterFuture ...
[17:26:08.250] - result already collected: FutureResult
[17:26:08.250] result() for ClusterFuture ... done
[17:26:08.250] result() for ClusterFuture ...
[17:26:08.250] - result already collected: FutureResult
[17:26:08.250] result() for ClusterFuture ... done
[17:26:08.251] result() for ClusterFuture ...
[17:26:08.251] - result already collected: FutureResult
[17:26:08.251] result() for ClusterFuture ... done
[17:26:08.251] result() for ClusterFuture ...
[17:26:08.251] - result already collected: FutureResult
[17:26:08.251] result() for ClusterFuture ... done
> print(js)
[[1]]
           event   category parent               start              at
1         create   overhead   <NA> 2024-03-26 17:26:05 0.00000000 secs
6         launch   overhead   <NA> 2024-03-26 17:26:05 0.02944398 secs
2      getWorker   overhead launch 2024-03-26 17:26:05 0.03516984 secs
3    eraseWorker   overhead launch 2024-03-26 17:26:05 0.03686190 secs
4 attachPackages   overhead launch 2024-03-26 17:26:05 0.03800297 secs
5  exportGlobals   overhead launch 2024-03-26 17:26:05 0.03880191 secs
9       evaluate evaluation   <NA> 2024-03-26 17:26:05 0.04210591 secs
7  receiveResult   overhead gather 2024-03-26 17:26:06 1.05225492 secs
8         gather   overhead   <NA> 2024-03-26 17:26:06 1.05386591 secs
           duration future_label                          future_uuid
1 1.038885e-02 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
6 1.285601e-02 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
2 2.341270e-04 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
3 3.571510e-04 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
4 5.102158e-05 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
5 1.955032e-03 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
9 8.531721e-01 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
7 3.690720e-04 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
8 5.240440e-04 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
                          session_uuid
1 25496884-314c-07e5-a64c-d3a6fa6dde89
6 25496884-314c-07e5-a64c-d3a6fa6dde89
2 25496884-314c-07e5-a64c-d3a6fa6dde89
3 25496884-314c-07e5-a64c-d3a6fa6dde89
4 25496884-314c-07e5-a64c-d3a6fa6dde89
5 25496884-314c-07e5-a64c-d3a6fa6dde89
9 7d474a27-903a-8e57-ccf2-28b6fcf09b9a
7 25496884-314c-07e5-a64c-d3a6fa6dde89
8 25496884-314c-07e5-a64c-d3a6fa6dde89

[[2]]
           event   category parent               start              at
1         create   overhead   <NA> 2024-03-26 17:26:05 0.00000000 secs
6         launch   overhead   <NA> 2024-03-26 17:26:05 0.02560306 secs
2      getWorker   overhead launch 2024-03-26 17:26:05 0.03114009 secs
3    eraseWorker   overhead launch 2024-03-26 17:26:05 0.03192496 secs
4 attachPackages   overhead launch 2024-03-26 17:26:05 0.11089611 secs
5  exportGlobals   overhead launch 2024-03-26 17:26:05 0.11155009 secs
9       evaluate evaluation   <NA> 2024-03-26 17:26:05 0.11451101 secs
7  receiveResult   overhead gather 2024-03-26 17:26:06 1.17869711 secs
8         gather   overhead   <NA> 2024-03-26 17:26:06 1.18005896 secs
           duration future_label                          future_uuid
1 5.018950e-03 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
6 8.899403e-02 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
2 1.339912e-04 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
3 7.832694e-02 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
4 4.196167e-05 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
5 1.735926e-03 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
9 1.063528e+00 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
7 2.889633e-04 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
8 4.911423e-04 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
                          session_uuid
1 25496884-314c-07e5-a64c-d3a6fa6dde89
6 25496884-314c-07e5-a64c-d3a6fa6dde89
2 25496884-314c-07e5-a64c-d3a6fa6dde89
3 25496884-314c-07e5-a64c-d3a6fa6dde89
4 25496884-314c-07e5-a64c-d3a6fa6dde89
5 25496884-314c-07e5-a64c-d3a6fa6dde89
9 96f74c0d-62c1-9bde-a314-f528620cc6eb
7 25496884-314c-07e5-a64c-d3a6fa6dde89
8 25496884-314c-07e5-a64c-d3a6fa6dde89

[[3]]
           event   category parent               start              at
1         create   overhead   <NA> 2024-03-26 17:26:05 0.00000000 secs
6         launch   overhead   <NA> 2024-03-26 17:26:05 0.02162099 secs
2      getWorker   overhead launch 2024-03-26 17:26:05 0.02714896 secs
3    eraseWorker   overhead launch 2024-03-26 17:26:06 0.89932394 secs
4 attachPackages   overhead launch 2024-03-26 17:26:06 0.90035415 secs
5  exportGlobals   overhead launch 2024-03-26 17:26:06 0.90102005 secs
9       evaluate evaluation   <NA> 2024-03-26 17:26:06 0.90397906 secs
7  receiveResult   overhead gather 2024-03-26 17:26:08 2.42588902 secs
8         gather   overhead   <NA> 2024-03-26 17:26:08 2.42925215 secs
           duration future_label                          future_uuid
1 4.209042e-03 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
6 8.825331e-01 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
2 8.715272e-01 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
3 3.859997e-04 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
4 4.196167e-05 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
5 1.764059e-03 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
9 1.521289e+00 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
7 3.111362e-04 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
8 4.990101e-04 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
                          session_uuid
1 25496884-314c-07e5-a64c-d3a6fa6dde89
6 25496884-314c-07e5-a64c-d3a6fa6dde89
2 25496884-314c-07e5-a64c-d3a6fa6dde89
3 25496884-314c-07e5-a64c-d3a6fa6dde89
4 25496884-314c-07e5-a64c-d3a6fa6dde89
5 25496884-314c-07e5-a64c-d3a6fa6dde89
9 7d474a27-903a-8e57-ccf2-28b6fcf09b9a
7 25496884-314c-07e5-a64c-d3a6fa6dde89
8 25496884-314c-07e5-a64c-d3a6fa6dde89

> stopifnot(
+   is.list(js),
+   all(vapply(js, FUN = is.data.frame, FUN.VALUE = NA))
+ )
>   
> ## Shut down parallel workers
> plan(sequential)
[17:26:08.259] plan(): Setting new future strategy stack:
[17:26:08.259] List of future strategies:
[17:26:08.259] 1. sequential:
[17:26:08.259]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:08.259]    - tweaked: FALSE
[17:26:08.259]    - call: plan(sequential)
[17:26:08.260] plan(): nbrOfWorkers() = 1
> 
> message("*** capture_journals() ... done")
*** capture_journals() ... done
> 
> 
> message("*** summary() of FutureJournal ...")
*** summary() of FutureJournal ...
> 
> js <- do.call(rbind, js)
> print(js)
            event   category parent               start              at
1          create   overhead   <NA> 2024-03-26 17:26:05 0.00000000 secs
6          launch   overhead   <NA> 2024-03-26 17:26:05 0.02944398 secs
2       getWorker   overhead launch 2024-03-26 17:26:05 0.03516984 secs
3     eraseWorker   overhead launch 2024-03-26 17:26:05 0.03686190 secs
4  attachPackages   overhead launch 2024-03-26 17:26:05 0.03800297 secs
5   exportGlobals   overhead launch 2024-03-26 17:26:05 0.03880191 secs
9        evaluate evaluation   <NA> 2024-03-26 17:26:05 0.04210591 secs
7   receiveResult   overhead gather 2024-03-26 17:26:06 1.05225492 secs
8          gather   overhead   <NA> 2024-03-26 17:26:06 1.05386591 secs
11         create   overhead   <NA> 2024-03-26 17:26:05 0.00000000 secs
61         launch   overhead   <NA> 2024-03-26 17:26:05 0.02560306 secs
21      getWorker   overhead launch 2024-03-26 17:26:05 0.03114009 secs
31    eraseWorker   overhead launch 2024-03-26 17:26:05 0.03192496 secs
41 attachPackages   overhead launch 2024-03-26 17:26:05 0.11089611 secs
51  exportGlobals   overhead launch 2024-03-26 17:26:05 0.11155009 secs
91       evaluate evaluation   <NA> 2024-03-26 17:26:05 0.11451101 secs
71  receiveResult   overhead gather 2024-03-26 17:26:06 1.17869711 secs
81         gather   overhead   <NA> 2024-03-26 17:26:06 1.18005896 secs
12         create   overhead   <NA> 2024-03-26 17:26:05 0.00000000 secs
62         launch   overhead   <NA> 2024-03-26 17:26:05 0.02162099 secs
22      getWorker   overhead launch 2024-03-26 17:26:05 0.02714896 secs
32    eraseWorker   overhead launch 2024-03-26 17:26:06 0.89932394 secs
42 attachPackages   overhead launch 2024-03-26 17:26:06 0.90035415 secs
52  exportGlobals   overhead launch 2024-03-26 17:26:06 0.90102005 secs
92       evaluate evaluation   <NA> 2024-03-26 17:26:06 0.90397906 secs
72  receiveResult   overhead gather 2024-03-26 17:26:08 2.42588902 secs
82         gather   overhead   <NA> 2024-03-26 17:26:08 2.42925215 secs
            duration future_label                          future_uuid
1  1.038885e-02 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
6  1.285601e-02 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
2  2.341270e-04 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
3  3.571510e-04 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
4  5.102158e-05 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
5  1.955032e-03 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
9  8.531721e-01 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
7  3.690720e-04 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
8  5.240440e-04 secs         <NA> 84096823-9803-f301-f28c-8a985c5a85a6
11 5.018950e-03 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
61 8.899403e-02 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
21 1.339912e-04 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
31 7.832694e-02 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
41 4.196167e-05 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
51 1.735926e-03 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
91 1.063528e+00 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
71 2.889633e-04 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
81 4.911423e-04 secs         <NA> 91991976-ac18-05e7-df61-4d7fcaecf0ab
12 4.209042e-03 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
62 8.825331e-01 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
22 8.715272e-01 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
32 3.859997e-04 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
42 4.196167e-05 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
52 1.764059e-03 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
92 1.521289e+00 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
72 3.111362e-04 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
82 4.990101e-04 secs         <NA> 15425733-278b-89e8-4b9d-6ed221d1adb3
                           session_uuid
1  25496884-314c-07e5-a64c-d3a6fa6dde89
6  25496884-314c-07e5-a64c-d3a6fa6dde89
2  25496884-314c-07e5-a64c-d3a6fa6dde89
3  25496884-314c-07e5-a64c-d3a6fa6dde89
4  25496884-314c-07e5-a64c-d3a6fa6dde89
5  25496884-314c-07e5-a64c-d3a6fa6dde89
9  7d474a27-903a-8e57-ccf2-28b6fcf09b9a
7  25496884-314c-07e5-a64c-d3a6fa6dde89
8  25496884-314c-07e5-a64c-d3a6fa6dde89
11 25496884-314c-07e5-a64c-d3a6fa6dde89
61 25496884-314c-07e5-a64c-d3a6fa6dde89
21 25496884-314c-07e5-a64c-d3a6fa6dde89
31 25496884-314c-07e5-a64c-d3a6fa6dde89
41 25496884-314c-07e5-a64c-d3a6fa6dde89
51 25496884-314c-07e5-a64c-d3a6fa6dde89
91 96f74c0d-62c1-9bde-a314-f528620cc6eb
71 25496884-314c-07e5-a64c-d3a6fa6dde89
81 25496884-314c-07e5-a64c-d3a6fa6dde89
12 25496884-314c-07e5-a64c-d3a6fa6dde89
62 25496884-314c-07e5-a64c-d3a6fa6dde89
22 25496884-314c-07e5-a64c-d3a6fa6dde89
32 25496884-314c-07e5-a64c-d3a6fa6dde89
42 25496884-314c-07e5-a64c-d3a6fa6dde89
52 25496884-314c-07e5-a64c-d3a6fa6dde89
92 7d474a27-903a-8e57-ccf2-28b6fcf09b9a
72 25496884-314c-07e5-a64c-d3a6fa6dde89
82 25496884-314c-07e5-a64c-d3a6fa6dde89
> 
> stats <- summary(js)
> print(stats)
Number of futures: 3
  summary       evaluate evaluate_ratio        overhead overhead_ratio
1     min 0.8531721 secs      0.8091618 0.02376890 secs     0.02254280
2    mean 1.1459963 secs      0.7370239 0.33517138 secs     0.21555857
3  median 1.0635281 secs      0.9008750 0.09450412 secs     0.08005092
4     max 1.5212889 secs      0.6261089 0.88724113 secs     0.36515720
5   total 3.4379890 secs      0.7370239 1.00551414 secs     0.21555857
       duration      walltime
1 1.054390 secs 1.054390 secs
2 1.554897 secs 1.554897 secs
3 1.180550 secs 1.180550 secs
4 2.429751 secs 2.429751 secs
5 4.664691 secs 4.664691 secs
> 
> message("*** summary() of FutureJournal ... done")
*** summary() of FutureJournal ... done
> 
> #source("incl/end.R")
> 
> proc.time()
   user  system elapsed 
   0.46    0.12    3.64