R Under development (unstable) (2024-07-28 r86931 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:38.928] plan(): Setting new future strategy stack:
[17:26:38.930] List of future strategies:
[17:26:38.930] 1. sequential:
[17:26:38.930]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:38.930]    - tweaked: FALSE
[17:26:38.930]    - call: future::plan("sequential")
[17:26:38.957] 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:38.971] plan(): Setting new future strategy stack:
[17:26:38.971] List of future strategies:
[17:26:38.971] 1. multisession:
[17:26:38.971]    - args: function (..., workers = 2, envir = parent.frame())
[17:26:38.971]    - tweaked: TRUE
[17:26:38.971]    - call: plan(multisession, workers = 2)
[17:26:38.997] plan(): plan_init() of 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:26:38.997] multisession:
[17:26:38.997] - args: function (..., workers = 2, envir = parent.frame())
[17:26:38.997] - tweaked: TRUE
[17:26:38.997] - call: plan(multisession, workers = 2)
[17:26:39.000] getGlobalsAndPackages() ...
[17:26:39.000] Not searching for globals
[17:26:39.001] - globals: [0] <none>
[17:26:39.001] getGlobalsAndPackages() ... DONE
[17:26:39.002] [local output] makeClusterPSOCK() ...
[17:26:39.050] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:26:39.058] [local output] Base port: 22197
[17:26:39.058] [local output] Getting setup options for 2 cluster nodes ...
[17:26:39.059] [local output]  - Node #1 of 2 ...
[17:26:39.059] [local output] localMachine=TRUE => revtunnel=FALSE

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

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

[17:26:39.504] [local output] Rscript port: 22197

[17:26:39.504] [local output] Getting setup options for 2 cluster nodes ... done
[17:26:39.504] [local output]  - Parallel setup requested for some PSOCK nodes
[17:26:39.505] [local output] Setting up PSOCK nodes in parallel
[17:26:39.505] List of 36
[17:26:39.505]  $ worker          : chr "localhost"
[17:26:39.505]   ..- attr(*, "localhost")= logi TRUE
[17:26:39.505]  $ master          : chr "localhost"
[17:26:39.505]  $ port            : int 22197
[17:26:39.505]  $ connectTimeout  : num 120
[17:26:39.505]  $ timeout         : num 120
[17:26:39.505]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:26:39.505]  $ homogeneous     : logi TRUE
[17:26:39.505]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=capture_journals.R:48344:CRANWIN"| __truncated__
[17:26:39.505]  $ rscript_envs    : NULL
[17:26:39.505]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:26:39.505]  $ rscript_startup : NULL
[17:26:39.505]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[17:26:39.505]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:26:39.505]  $ methods         : logi TRUE
[17:26:39.505]  $ socketOptions   : chr "no-delay"
[17:26:39.505]  $ useXDR          : logi FALSE
[17:26:39.505]  $ outfile         : chr "/dev/null"
[17:26:39.505]  $ renice          : int NA
[17:26:39.505]  $ rshcmd          : NULL
[17:26:39.505]  $ user            : chr(0) 
[17:26:39.505]  $ revtunnel       : logi FALSE
[17:26:39.505]  $ rshlogfile      : NULL
[17:26:39.505]  $ rshopts         : chr(0) 
[17:26:39.505]  $ rank            : int 1
[17:26:39.505]  $ manual          : logi FALSE
[17:26:39.505]  $ dryrun          : logi FALSE
[17:26:39.505]  $ quiet           : logi FALSE
[17:26:39.505]  $ setup_strategy  : chr "parallel"
[17:26:39.505]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:26:39.505]  $ pidfile         : chr "D:/temp/RtmpeYYS1s/worker.rank=1.parallelly.parent=48344.bcd8512a61ab.pid"
[17:26:39.505]  $ rshcmd_label    : NULL
[17:26:39.505]  $ rsh_call        : NULL
[17:26:39.505]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:26:39.505]  $ localMachine    : logi TRUE
[17:26:39.505]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:26:39.505]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:26:39.505]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:26:39.505]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:26:39.505]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:26:39.505]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[17:26:39.505]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[17:26:39.505]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:26:39.505]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:26:39.505]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:26:39.505]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:26:39.505]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:26:39.505]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:26:39.505]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:26:39.505]  $ arguments       :List of 28
[17:26:39.505]   ..$ worker          : chr "localhost"
[17:26:39.505]   ..$ master          : NULL
[17:26:39.505]   ..$ port            : int 22197
[17:26:39.505]   ..$ connectTimeout  : num 120
[17:26:39.505]   ..$ timeout         : num 120
[17:26:39.505]   ..$ rscript         : NULL
[17:26:39.505]   ..$ homogeneous     : NULL
[17:26:39.505]   ..$ rscript_args    : NULL
[17:26:39.505]   ..$ rscript_envs    : NULL
[17:26:39.505]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:26:39.505]   ..$ rscript_startup : NULL
[17:26:39.505]   ..$ rscript_sh      : chr "auto"
[17:26:39.505]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:26:39.505]   ..$ methods         : logi TRUE
[17:26:39.505]   ..$ socketOptions   : chr "no-delay"
[17:26:39.505]   ..$ useXDR          : logi FALSE
[17:26:39.505]   ..$ outfile         : chr "/dev/null"
[17:26:39.505]   ..$ renice          : int NA
[17:26:39.505]   ..$ rshcmd          : NULL
[17:26:39.505]   ..$ user            : NULL
[17:26:39.505]   ..$ revtunnel       : logi NA
[17:26:39.505]   ..$ rshlogfile      : NULL
[17:26:39.505]   ..$ rshopts         : NULL
[17:26:39.505]   ..$ rank            : int 1
[17:26:39.505]   ..$ manual          : logi FALSE
[17:26:39.505]   ..$ dryrun          : logi FALSE
[17:26:39.505]   ..$ quiet           : logi FALSE
[17:26:39.505]   ..$ setup_strategy  : chr "parallel"
[17:26:39.505]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:26:39.529] [local output] System call to launch all workers:
[17:26:39.529] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=capture_journals.R:48344:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpeYYS1s/worker.rank=1.parallelly.parent=48344.bcd8512a61ab.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=22197 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:26:39.529] [local output] Starting PSOCK main server
[17:26:39.538] [local output] Workers launched
[17:26:39.538] [local output] Waiting for workers to connect back
[17:26:39.538]  - [local output] 0 workers out of 2 ready
[17:26:39.777]  - [local output] 0 workers out of 2 ready
[17:26:39.777]  - [local output] 1 workers out of 2 ready
[17:26:39.797]  - [local output] 1 workers out of 2 ready
[17:26:39.798]  - [local output] 2 workers out of 2 ready
[17:26:39.798] [local output] Launching of 2 workers completed
[17:26:39.798] [local output] Number of nodes in cluster: 2
[17:26:39.799] [local output] Collecting session information from 2 workers
[17:26:39.801] [local output]  - Worker #1 of 2
[17:26:39.802] [local output]  - Worker #2 of 2
[17:26:39.803] [local output] makeClusterPSOCK() ... done
[17:26:39.821] Packages needed by the future expression (n = 0): <none>
[17:26:39.821] Packages needed by future strategies (n = 0): <none>
[17:26:39.823] {
[17:26:39.823]     {
[17:26:39.823]         {
[17:26:39.823]             ...future.startTime <- base::Sys.time()
[17:26:39.823]             {
[17:26:39.823]                 {
[17:26:39.823]                   {
[17:26:39.823]                     {
[17:26:39.823]                       base::local({
[17:26:39.823]                         has_future <- base::requireNamespace("future", 
[17:26:39.823]                           quietly = TRUE)
[17:26:39.823]                         if (has_future) {
[17:26:39.823]                           ns <- base::getNamespace("future")
[17:26:39.823]                           version <- ns[[".package"]][["version"]]
[17:26:39.823]                           if (is.null(version)) 
[17:26:39.823]                             version <- utils::packageVersion("future")
[17:26:39.823]                         }
[17:26:39.823]                         else {
[17:26:39.823]                           version <- NULL
[17:26:39.823]                         }
[17:26:39.823]                         if (!has_future || version < "1.8.0") {
[17:26:39.823]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:39.823]                             "", base::R.version$version.string), 
[17:26:39.823]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:39.823]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:39.823]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:39.823]                               "release", "version")], collapse = " "), 
[17:26:39.823]                             hostname = base::Sys.info()[["nodename"]])
[17:26:39.823]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:39.823]                             info)
[17:26:39.823]                           info <- base::paste(info, collapse = "; ")
[17:26:39.823]                           if (!has_future) {
[17:26:39.823]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:39.823]                               info)
[17:26:39.823]                           }
[17:26:39.823]                           else {
[17:26:39.823]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:39.823]                               info, version)
[17:26:39.823]                           }
[17:26:39.823]                           base::stop(msg)
[17:26:39.823]                         }
[17:26:39.823]                       })
[17:26:39.823]                     }
[17:26:39.823]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:39.823]                     base::options(mc.cores = 1L)
[17:26:39.823]                   }
[17:26:39.823]                   ...future.strategy.old <- future::plan("list")
[17:26:39.823]                   options(future.plan = NULL)
[17:26:39.823]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:39.823]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:39.823]                 }
[17:26:39.823]                 ...future.workdir <- getwd()
[17:26:39.823]             }
[17:26:39.823]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:39.823]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:39.823]         }
[17:26:39.823]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:39.823]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:39.823]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:39.823]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:39.823]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:39.823]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:39.823]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:39.823]             base::names(...future.oldOptions))
[17:26:39.823]     }
[17:26:39.823]     if (FALSE) {
[17:26:39.823]     }
[17:26:39.823]     else {
[17:26:39.823]         if (TRUE) {
[17:26:39.823]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:39.823]                 open = "w")
[17:26:39.823]         }
[17:26:39.823]         else {
[17:26:39.823]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:39.823]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:39.823]         }
[17:26:39.823]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:39.823]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:39.823]             base::sink(type = "output", split = FALSE)
[17:26:39.823]             base::close(...future.stdout)
[17:26:39.823]         }, add = TRUE)
[17:26:39.823]     }
[17:26:39.823]     ...future.frame <- base::sys.nframe()
[17:26:39.823]     ...future.conditions <- base::list()
[17:26:39.823]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:39.823]     if (FALSE) {
[17:26:39.823]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:39.823]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:39.823]     }
[17:26:39.823]     ...future.result <- base::tryCatch({
[17:26:39.823]         base::withCallingHandlers({
[17:26:39.823]             ...future.value <- base::withVisible(base::local({
[17:26:39.823]                 ...future.makeSendCondition <- base::local({
[17:26:39.823]                   sendCondition <- NULL
[17:26:39.823]                   function(frame = 1L) {
[17:26:39.823]                     if (is.function(sendCondition)) 
[17:26:39.823]                       return(sendCondition)
[17:26:39.823]                     ns <- getNamespace("parallel")
[17:26:39.823]                     if (exists("sendData", mode = "function", 
[17:26:39.823]                       envir = ns)) {
[17:26:39.823]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:39.823]                         envir = ns)
[17:26:39.823]                       envir <- sys.frame(frame)
[17:26:39.823]                       master <- NULL
[17:26:39.823]                       while (!identical(envir, .GlobalEnv) && 
[17:26:39.823]                         !identical(envir, emptyenv())) {
[17:26:39.823]                         if (exists("master", mode = "list", envir = envir, 
[17:26:39.823]                           inherits = FALSE)) {
[17:26:39.823]                           master <- get("master", mode = "list", 
[17:26:39.823]                             envir = envir, inherits = FALSE)
[17:26:39.823]                           if (inherits(master, c("SOCKnode", 
[17:26:39.823]                             "SOCK0node"))) {
[17:26:39.823]                             sendCondition <<- function(cond) {
[17:26:39.823]                               data <- list(type = "VALUE", value = cond, 
[17:26:39.823]                                 success = TRUE)
[17:26:39.823]                               parallel_sendData(master, data)
[17:26:39.823]                             }
[17:26:39.823]                             return(sendCondition)
[17:26:39.823]                           }
[17:26:39.823]                         }
[17:26:39.823]                         frame <- frame + 1L
[17:26:39.823]                         envir <- sys.frame(frame)
[17:26:39.823]                       }
[17:26:39.823]                     }
[17:26:39.823]                     sendCondition <<- function(cond) NULL
[17:26:39.823]                   }
[17:26:39.823]                 })
[17:26:39.823]                 withCallingHandlers({
[17:26:39.823]                   NA
[17:26:39.823]                 }, immediateCondition = function(cond) {
[17:26:39.823]                   sendCondition <- ...future.makeSendCondition()
[17:26:39.823]                   sendCondition(cond)
[17:26:39.823]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:39.823]                   {
[17:26:39.823]                     inherits <- base::inherits
[17:26:39.823]                     invokeRestart <- base::invokeRestart
[17:26:39.823]                     is.null <- base::is.null
[17:26:39.823]                     muffled <- FALSE
[17:26:39.823]                     if (inherits(cond, "message")) {
[17:26:39.823]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:39.823]                       if (muffled) 
[17:26:39.823]                         invokeRestart("muffleMessage")
[17:26:39.823]                     }
[17:26:39.823]                     else if (inherits(cond, "warning")) {
[17:26:39.823]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:39.823]                       if (muffled) 
[17:26:39.823]                         invokeRestart("muffleWarning")
[17:26:39.823]                     }
[17:26:39.823]                     else if (inherits(cond, "condition")) {
[17:26:39.823]                       if (!is.null(pattern)) {
[17:26:39.823]                         computeRestarts <- base::computeRestarts
[17:26:39.823]                         grepl <- base::grepl
[17:26:39.823]                         restarts <- computeRestarts(cond)
[17:26:39.823]                         for (restart in restarts) {
[17:26:39.823]                           name <- restart$name
[17:26:39.823]                           if (is.null(name)) 
[17:26:39.823]                             next
[17:26:39.823]                           if (!grepl(pattern, name)) 
[17:26:39.823]                             next
[17:26:39.823]                           invokeRestart(restart)
[17:26:39.823]                           muffled <- TRUE
[17:26:39.823]                           break
[17:26:39.823]                         }
[17:26:39.823]                       }
[17:26:39.823]                     }
[17:26:39.823]                     invisible(muffled)
[17:26:39.823]                   }
[17:26:39.823]                   muffleCondition(cond)
[17:26:39.823]                 })
[17:26:39.823]             }))
[17:26:39.823]             future::FutureResult(value = ...future.value$value, 
[17:26:39.823]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:39.823]                   ...future.rng), globalenv = if (FALSE) 
[17:26:39.823]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:39.823]                     ...future.globalenv.names))
[17:26:39.823]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:39.823]         }, condition = base::local({
[17:26:39.823]             c <- base::c
[17:26:39.823]             inherits <- base::inherits
[17:26:39.823]             invokeRestart <- base::invokeRestart
[17:26:39.823]             length <- base::length
[17:26:39.823]             list <- base::list
[17:26:39.823]             seq.int <- base::seq.int
[17:26:39.823]             signalCondition <- base::signalCondition
[17:26:39.823]             sys.calls <- base::sys.calls
[17:26:39.823]             `[[` <- base::`[[`
[17:26:39.823]             `+` <- base::`+`
[17:26:39.823]             `<<-` <- base::`<<-`
[17:26:39.823]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:39.823]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:39.823]                   3L)]
[17:26:39.823]             }
[17:26:39.823]             function(cond) {
[17:26:39.823]                 is_error <- inherits(cond, "error")
[17:26:39.823]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:39.823]                   NULL)
[17:26:39.823]                 if (is_error) {
[17:26:39.823]                   sessionInformation <- function() {
[17:26:39.823]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:39.823]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:39.823]                       search = base::search(), system = base::Sys.info())
[17:26:39.823]                   }
[17:26:39.823]                   ...future.conditions[[length(...future.conditions) + 
[17:26:39.823]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:39.823]                     cond$call), session = sessionInformation(), 
[17:26:39.823]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:39.823]                   signalCondition(cond)
[17:26:39.823]                 }
[17:26:39.823]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:39.823]                 "immediateCondition"))) {
[17:26:39.823]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:39.823]                   ...future.conditions[[length(...future.conditions) + 
[17:26:39.823]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:39.823]                   if (TRUE && !signal) {
[17:26:39.823]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:39.823]                     {
[17:26:39.823]                       inherits <- base::inherits
[17:26:39.823]                       invokeRestart <- base::invokeRestart
[17:26:39.823]                       is.null <- base::is.null
[17:26:39.823]                       muffled <- FALSE
[17:26:39.823]                       if (inherits(cond, "message")) {
[17:26:39.823]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:39.823]                         if (muffled) 
[17:26:39.823]                           invokeRestart("muffleMessage")
[17:26:39.823]                       }
[17:26:39.823]                       else if (inherits(cond, "warning")) {
[17:26:39.823]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:39.823]                         if (muffled) 
[17:26:39.823]                           invokeRestart("muffleWarning")
[17:26:39.823]                       }
[17:26:39.823]                       else if (inherits(cond, "condition")) {
[17:26:39.823]                         if (!is.null(pattern)) {
[17:26:39.823]                           computeRestarts <- base::computeRestarts
[17:26:39.823]                           grepl <- base::grepl
[17:26:39.823]                           restarts <- computeRestarts(cond)
[17:26:39.823]                           for (restart in restarts) {
[17:26:39.823]                             name <- restart$name
[17:26:39.823]                             if (is.null(name)) 
[17:26:39.823]                               next
[17:26:39.823]                             if (!grepl(pattern, name)) 
[17:26:39.823]                               next
[17:26:39.823]                             invokeRestart(restart)
[17:26:39.823]                             muffled <- TRUE
[17:26:39.823]                             break
[17:26:39.823]                           }
[17:26:39.823]                         }
[17:26:39.823]                       }
[17:26:39.823]                       invisible(muffled)
[17:26:39.823]                     }
[17:26:39.823]                     muffleCondition(cond, pattern = "^muffle")
[17:26:39.823]                   }
[17:26:39.823]                 }
[17:26:39.823]                 else {
[17:26:39.823]                   if (TRUE) {
[17:26:39.823]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:39.823]                     {
[17:26:39.823]                       inherits <- base::inherits
[17:26:39.823]                       invokeRestart <- base::invokeRestart
[17:26:39.823]                       is.null <- base::is.null
[17:26:39.823]                       muffled <- FALSE
[17:26:39.823]                       if (inherits(cond, "message")) {
[17:26:39.823]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:39.823]                         if (muffled) 
[17:26:39.823]                           invokeRestart("muffleMessage")
[17:26:39.823]                       }
[17:26:39.823]                       else if (inherits(cond, "warning")) {
[17:26:39.823]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:39.823]                         if (muffled) 
[17:26:39.823]                           invokeRestart("muffleWarning")
[17:26:39.823]                       }
[17:26:39.823]                       else if (inherits(cond, "condition")) {
[17:26:39.823]                         if (!is.null(pattern)) {
[17:26:39.823]                           computeRestarts <- base::computeRestarts
[17:26:39.823]                           grepl <- base::grepl
[17:26:39.823]                           restarts <- computeRestarts(cond)
[17:26:39.823]                           for (restart in restarts) {
[17:26:39.823]                             name <- restart$name
[17:26:39.823]                             if (is.null(name)) 
[17:26:39.823]                               next
[17:26:39.823]                             if (!grepl(pattern, name)) 
[17:26:39.823]                               next
[17:26:39.823]                             invokeRestart(restart)
[17:26:39.823]                             muffled <- TRUE
[17:26:39.823]                             break
[17:26:39.823]                           }
[17:26:39.823]                         }
[17:26:39.823]                       }
[17:26:39.823]                       invisible(muffled)
[17:26:39.823]                     }
[17:26:39.823]                     muffleCondition(cond, pattern = "^muffle")
[17:26:39.823]                   }
[17:26:39.823]                 }
[17:26:39.823]             }
[17:26:39.823]         }))
[17:26:39.823]     }, error = function(ex) {
[17:26:39.823]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:39.823]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:39.823]                 ...future.rng), started = ...future.startTime, 
[17:26:39.823]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:39.823]             version = "1.8"), class = "FutureResult")
[17:26:39.823]     }, finally = {
[17:26:39.823]         if (!identical(...future.workdir, getwd())) 
[17:26:39.823]             setwd(...future.workdir)
[17:26:39.823]         {
[17:26:39.823]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:39.823]                 ...future.oldOptions$nwarnings <- NULL
[17:26:39.823]             }
[17:26:39.823]             base::options(...future.oldOptions)
[17:26:39.823]             if (.Platform$OS.type == "windows") {
[17:26:39.823]                 old_names <- names(...future.oldEnvVars)
[17:26:39.823]                 envs <- base::Sys.getenv()
[17:26:39.823]                 names <- names(envs)
[17:26:39.823]                 common <- intersect(names, old_names)
[17:26:39.823]                 added <- setdiff(names, old_names)
[17:26:39.823]                 removed <- setdiff(old_names, names)
[17:26:39.823]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:39.823]                   envs[common]]
[17:26:39.823]                 NAMES <- toupper(changed)
[17:26:39.823]                 args <- list()
[17:26:39.823]                 for (kk in seq_along(NAMES)) {
[17:26:39.823]                   name <- changed[[kk]]
[17:26:39.823]                   NAME <- NAMES[[kk]]
[17:26:39.823]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:39.823]                     next
[17:26:39.823]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:39.823]                 }
[17:26:39.823]                 NAMES <- toupper(added)
[17:26:39.823]                 for (kk in seq_along(NAMES)) {
[17:26:39.823]                   name <- added[[kk]]
[17:26:39.823]                   NAME <- NAMES[[kk]]
[17:26:39.823]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:39.823]                     next
[17:26:39.823]                   args[[name]] <- ""
[17:26:39.823]                 }
[17:26:39.823]                 NAMES <- toupper(removed)
[17:26:39.823]                 for (kk in seq_along(NAMES)) {
[17:26:39.823]                   name <- removed[[kk]]
[17:26:39.823]                   NAME <- NAMES[[kk]]
[17:26:39.823]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:39.823]                     next
[17:26:39.823]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:39.823]                 }
[17:26:39.823]                 if (length(args) > 0) 
[17:26:39.823]                   base::do.call(base::Sys.setenv, args = args)
[17:26:39.823]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:39.823]             }
[17:26:39.823]             else {
[17:26:39.823]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:39.823]             }
[17:26:39.823]             {
[17:26:39.823]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:39.823]                   0L) {
[17:26:39.823]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:39.823]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:39.823]                   base::options(opts)
[17:26:39.823]                 }
[17:26:39.823]                 {
[17:26:39.823]                   {
[17:26:39.823]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:39.823]                     NULL
[17:26:39.823]                   }
[17:26:39.823]                   options(future.plan = NULL)
[17:26:39.823]                   if (is.na(NA_character_)) 
[17:26:39.823]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:39.823]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:39.823]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:39.823]                     .init = FALSE)
[17:26:39.823]                 }
[17:26:39.823]             }
[17:26:39.823]         }
[17:26:39.823]     })
[17:26:39.823]     if (TRUE) {
[17:26:39.823]         base::sink(type = "output", split = FALSE)
[17:26:39.823]         if (TRUE) {
[17:26:39.823]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:39.823]         }
[17:26:39.823]         else {
[17:26:39.823]             ...future.result["stdout"] <- base::list(NULL)
[17:26:39.823]         }
[17:26:39.823]         base::close(...future.stdout)
[17:26:39.823]         ...future.stdout <- NULL
[17:26:39.823]     }
[17:26:39.823]     ...future.result$conditions <- ...future.conditions
[17:26:39.823]     ...future.result$finished <- base::Sys.time()
[17:26:39.823]     ...future.result
[17:26:39.823] }
[17:26:39.985] MultisessionFuture started
[17:26:39.986] result() for ClusterFuture ...
[17:26:39.987] receiveMessageFromWorker() for ClusterFuture ...
[17:26:39.987] - Validating connection of MultisessionFuture
[17:26:40.092] - received message: FutureResult
[17:26:40.092] - Received FutureResult
[17:26:40.098] - Erased future from FutureRegistry
[17:26:40.099] result() for ClusterFuture ...
[17:26:40.099] - result already collected: FutureResult
[17:26:40.100] result() for ClusterFuture ... done
[17:26:40.100] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:40.100] result() for ClusterFuture ... done
[17:26:40.101] result() for ClusterFuture ...
[17:26:40.101] - result already collected: FutureResult
[17:26:40.101] result() for ClusterFuture ... done
[17:26:40.102] plan(): plan_init() of 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:26:40.102] plan(): nbrOfWorkers() = 2
> js <- capture_journals({
+   fs <- lapply(3:1, FUN = function(x) future(slow_fcn(x)))
+   vs <- value(fs)
+ })
[17:26:40.103] getGlobalsAndPackages() ...
[17:26:40.103] Searching for globals...
[17:26:40.114] - globals found: [6] 'slow_fcn', 'x', '{', 'Sys.sleep', '+', '/'
[17:26:40.114] Searching for globals ... DONE
[17:26:40.115] Resolving globals: FALSE
[17:26:40.117] The total size of the 2 globals is 243 bytes (243 bytes)
[17:26:40.118] The total size of the 2 globals exported for future expression ('slow_fcn(x)') is 243 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'slow_fcn' (208 bytes of class 'function') and 'x' (35 bytes of class 'numeric')
[17:26:40.119] - globals: [2] 'slow_fcn', 'x'
[17:26:40.119] 
[17:26:40.119] getGlobalsAndPackages() ... DONE
[17:26:40.122] run() for 'Future' ...
[17:26:40.123] - state: 'created'
[17:26:40.123] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:40.140] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:40.141] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:40.141]   - Field: 'node'
[17:26:40.141]   - Field: 'label'
[17:26:40.142]   - Field: 'local'
[17:26:40.142]   - Field: 'owner'
[17:26:40.142]   - Field: 'envir'
[17:26:40.143]   - Field: 'workers'
[17:26:40.143]   - Field: 'packages'
[17:26:40.143]   - Field: 'gc'
[17:26:40.144]   - Field: 'conditions'
[17:26:40.144]   - Field: 'persistent'
[17:26:40.144]   - Field: 'expr'
[17:26:40.145]   - Field: 'uuid'
[17:26:40.145]   - Field: 'seed'
[17:26:40.145]   - Field: 'version'
[17:26:40.145]   - Field: 'result'
[17:26:40.146]   - Field: 'asynchronous'
[17:26:40.146]   - Field: 'calls'
[17:26:40.146]   - Field: 'globals'
[17:26:40.147]   - Field: 'stdout'
[17:26:40.147]   - Field: 'earlySignal'
[17:26:40.147]   - Field: 'lazy'
[17:26:40.148]   - Field: 'state'
[17:26:40.148] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:40.148] - Launch lazy future ...
[17:26:40.149] Packages needed by the future expression (n = 0): <none>
[17:26:40.149] Packages needed by future strategies (n = 0): <none>
[17:26:40.151] {
[17:26:40.151]     {
[17:26:40.151]         {
[17:26:40.151]             ...future.startTime <- base::Sys.time()
[17:26:40.151]             {
[17:26:40.151]                 {
[17:26:40.151]                   {
[17:26:40.151]                     {
[17:26:40.151]                       base::local({
[17:26:40.151]                         has_future <- base::requireNamespace("future", 
[17:26:40.151]                           quietly = TRUE)
[17:26:40.151]                         if (has_future) {
[17:26:40.151]                           ns <- base::getNamespace("future")
[17:26:40.151]                           version <- ns[[".package"]][["version"]]
[17:26:40.151]                           if (is.null(version)) 
[17:26:40.151]                             version <- utils::packageVersion("future")
[17:26:40.151]                         }
[17:26:40.151]                         else {
[17:26:40.151]                           version <- NULL
[17:26:40.151]                         }
[17:26:40.151]                         if (!has_future || version < "1.8.0") {
[17:26:40.151]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:40.151]                             "", base::R.version$version.string), 
[17:26:40.151]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:40.151]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:40.151]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:40.151]                               "release", "version")], collapse = " "), 
[17:26:40.151]                             hostname = base::Sys.info()[["nodename"]])
[17:26:40.151]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:40.151]                             info)
[17:26:40.151]                           info <- base::paste(info, collapse = "; ")
[17:26:40.151]                           if (!has_future) {
[17:26:40.151]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:40.151]                               info)
[17:26:40.151]                           }
[17:26:40.151]                           else {
[17:26:40.151]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:40.151]                               info, version)
[17:26:40.151]                           }
[17:26:40.151]                           base::stop(msg)
[17:26:40.151]                         }
[17:26:40.151]                       })
[17:26:40.151]                     }
[17:26:40.151]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:40.151]                     base::options(mc.cores = 1L)
[17:26:40.151]                   }
[17:26:40.151]                   ...future.strategy.old <- future::plan("list")
[17:26:40.151]                   options(future.plan = NULL)
[17:26:40.151]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:40.151]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:40.151]                 }
[17:26:40.151]                 ...future.workdir <- getwd()
[17:26:40.151]             }
[17:26:40.151]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:40.151]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:40.151]         }
[17:26:40.151]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:40.151]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:40.151]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:40.151]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:40.151]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:40.151]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:40.151]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:40.151]             base::names(...future.oldOptions))
[17:26:40.151]     }
[17:26:40.151]     if (FALSE) {
[17:26:40.151]     }
[17:26:40.151]     else {
[17:26:40.151]         if (TRUE) {
[17:26:40.151]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:40.151]                 open = "w")
[17:26:40.151]         }
[17:26:40.151]         else {
[17:26:40.151]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:40.151]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:40.151]         }
[17:26:40.151]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:40.151]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:40.151]             base::sink(type = "output", split = FALSE)
[17:26:40.151]             base::close(...future.stdout)
[17:26:40.151]         }, add = TRUE)
[17:26:40.151]     }
[17:26:40.151]     ...future.frame <- base::sys.nframe()
[17:26:40.151]     ...future.conditions <- base::list()
[17:26:40.151]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:40.151]     if (FALSE) {
[17:26:40.151]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:40.151]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:40.151]     }
[17:26:40.151]     ...future.result <- base::tryCatch({
[17:26:40.151]         base::withCallingHandlers({
[17:26:40.151]             ...future.value <- base::withVisible(base::local({
[17:26:40.151]                 ...future.makeSendCondition <- base::local({
[17:26:40.151]                   sendCondition <- NULL
[17:26:40.151]                   function(frame = 1L) {
[17:26:40.151]                     if (is.function(sendCondition)) 
[17:26:40.151]                       return(sendCondition)
[17:26:40.151]                     ns <- getNamespace("parallel")
[17:26:40.151]                     if (exists("sendData", mode = "function", 
[17:26:40.151]                       envir = ns)) {
[17:26:40.151]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:40.151]                         envir = ns)
[17:26:40.151]                       envir <- sys.frame(frame)
[17:26:40.151]                       master <- NULL
[17:26:40.151]                       while (!identical(envir, .GlobalEnv) && 
[17:26:40.151]                         !identical(envir, emptyenv())) {
[17:26:40.151]                         if (exists("master", mode = "list", envir = envir, 
[17:26:40.151]                           inherits = FALSE)) {
[17:26:40.151]                           master <- get("master", mode = "list", 
[17:26:40.151]                             envir = envir, inherits = FALSE)
[17:26:40.151]                           if (inherits(master, c("SOCKnode", 
[17:26:40.151]                             "SOCK0node"))) {
[17:26:40.151]                             sendCondition <<- function(cond) {
[17:26:40.151]                               data <- list(type = "VALUE", value = cond, 
[17:26:40.151]                                 success = TRUE)
[17:26:40.151]                               parallel_sendData(master, data)
[17:26:40.151]                             }
[17:26:40.151]                             return(sendCondition)
[17:26:40.151]                           }
[17:26:40.151]                         }
[17:26:40.151]                         frame <- frame + 1L
[17:26:40.151]                         envir <- sys.frame(frame)
[17:26:40.151]                       }
[17:26:40.151]                     }
[17:26:40.151]                     sendCondition <<- function(cond) NULL
[17:26:40.151]                   }
[17:26:40.151]                 })
[17:26:40.151]                 withCallingHandlers({
[17:26:40.151]                   slow_fcn(x)
[17:26:40.151]                 }, immediateCondition = function(cond) {
[17:26:40.151]                   sendCondition <- ...future.makeSendCondition()
[17:26:40.151]                   sendCondition(cond)
[17:26:40.151]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:40.151]                   {
[17:26:40.151]                     inherits <- base::inherits
[17:26:40.151]                     invokeRestart <- base::invokeRestart
[17:26:40.151]                     is.null <- base::is.null
[17:26:40.151]                     muffled <- FALSE
[17:26:40.151]                     if (inherits(cond, "message")) {
[17:26:40.151]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:40.151]                       if (muffled) 
[17:26:40.151]                         invokeRestart("muffleMessage")
[17:26:40.151]                     }
[17:26:40.151]                     else if (inherits(cond, "warning")) {
[17:26:40.151]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:40.151]                       if (muffled) 
[17:26:40.151]                         invokeRestart("muffleWarning")
[17:26:40.151]                     }
[17:26:40.151]                     else if (inherits(cond, "condition")) {
[17:26:40.151]                       if (!is.null(pattern)) {
[17:26:40.151]                         computeRestarts <- base::computeRestarts
[17:26:40.151]                         grepl <- base::grepl
[17:26:40.151]                         restarts <- computeRestarts(cond)
[17:26:40.151]                         for (restart in restarts) {
[17:26:40.151]                           name <- restart$name
[17:26:40.151]                           if (is.null(name)) 
[17:26:40.151]                             next
[17:26:40.151]                           if (!grepl(pattern, name)) 
[17:26:40.151]                             next
[17:26:40.151]                           invokeRestart(restart)
[17:26:40.151]                           muffled <- TRUE
[17:26:40.151]                           break
[17:26:40.151]                         }
[17:26:40.151]                       }
[17:26:40.151]                     }
[17:26:40.151]                     invisible(muffled)
[17:26:40.151]                   }
[17:26:40.151]                   muffleCondition(cond)
[17:26:40.151]                 })
[17:26:40.151]             }))
[17:26:40.151]             future::FutureResult(value = ...future.value$value, 
[17:26:40.151]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:40.151]                   ...future.rng), globalenv = if (FALSE) 
[17:26:40.151]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:40.151]                     ...future.globalenv.names))
[17:26:40.151]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:40.151]         }, condition = base::local({
[17:26:40.151]             c <- base::c
[17:26:40.151]             inherits <- base::inherits
[17:26:40.151]             invokeRestart <- base::invokeRestart
[17:26:40.151]             length <- base::length
[17:26:40.151]             list <- base::list
[17:26:40.151]             seq.int <- base::seq.int
[17:26:40.151]             signalCondition <- base::signalCondition
[17:26:40.151]             sys.calls <- base::sys.calls
[17:26:40.151]             `[[` <- base::`[[`
[17:26:40.151]             `+` <- base::`+`
[17:26:40.151]             `<<-` <- base::`<<-`
[17:26:40.151]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:40.151]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:40.151]                   3L)]
[17:26:40.151]             }
[17:26:40.151]             function(cond) {
[17:26:40.151]                 is_error <- inherits(cond, "error")
[17:26:40.151]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:40.151]                   NULL)
[17:26:40.151]                 if (is_error) {
[17:26:40.151]                   sessionInformation <- function() {
[17:26:40.151]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:40.151]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:40.151]                       search = base::search(), system = base::Sys.info())
[17:26:40.151]                   }
[17:26:40.151]                   ...future.conditions[[length(...future.conditions) + 
[17:26:40.151]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:40.151]                     cond$call), session = sessionInformation(), 
[17:26:40.151]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:40.151]                   signalCondition(cond)
[17:26:40.151]                 }
[17:26:40.151]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:40.151]                 "immediateCondition"))) {
[17:26:40.151]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:40.151]                   ...future.conditions[[length(...future.conditions) + 
[17:26:40.151]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:40.151]                   if (TRUE && !signal) {
[17:26:40.151]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:40.151]                     {
[17:26:40.151]                       inherits <- base::inherits
[17:26:40.151]                       invokeRestart <- base::invokeRestart
[17:26:40.151]                       is.null <- base::is.null
[17:26:40.151]                       muffled <- FALSE
[17:26:40.151]                       if (inherits(cond, "message")) {
[17:26:40.151]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:40.151]                         if (muffled) 
[17:26:40.151]                           invokeRestart("muffleMessage")
[17:26:40.151]                       }
[17:26:40.151]                       else if (inherits(cond, "warning")) {
[17:26:40.151]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:40.151]                         if (muffled) 
[17:26:40.151]                           invokeRestart("muffleWarning")
[17:26:40.151]                       }
[17:26:40.151]                       else if (inherits(cond, "condition")) {
[17:26:40.151]                         if (!is.null(pattern)) {
[17:26:40.151]                           computeRestarts <- base::computeRestarts
[17:26:40.151]                           grepl <- base::grepl
[17:26:40.151]                           restarts <- computeRestarts(cond)
[17:26:40.151]                           for (restart in restarts) {
[17:26:40.151]                             name <- restart$name
[17:26:40.151]                             if (is.null(name)) 
[17:26:40.151]                               next
[17:26:40.151]                             if (!grepl(pattern, name)) 
[17:26:40.151]                               next
[17:26:40.151]                             invokeRestart(restart)
[17:26:40.151]                             muffled <- TRUE
[17:26:40.151]                             break
[17:26:40.151]                           }
[17:26:40.151]                         }
[17:26:40.151]                       }
[17:26:40.151]                       invisible(muffled)
[17:26:40.151]                     }
[17:26:40.151]                     muffleCondition(cond, pattern = "^muffle")
[17:26:40.151]                   }
[17:26:40.151]                 }
[17:26:40.151]                 else {
[17:26:40.151]                   if (TRUE) {
[17:26:40.151]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:40.151]                     {
[17:26:40.151]                       inherits <- base::inherits
[17:26:40.151]                       invokeRestart <- base::invokeRestart
[17:26:40.151]                       is.null <- base::is.null
[17:26:40.151]                       muffled <- FALSE
[17:26:40.151]                       if (inherits(cond, "message")) {
[17:26:40.151]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:40.151]                         if (muffled) 
[17:26:40.151]                           invokeRestart("muffleMessage")
[17:26:40.151]                       }
[17:26:40.151]                       else if (inherits(cond, "warning")) {
[17:26:40.151]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:40.151]                         if (muffled) 
[17:26:40.151]                           invokeRestart("muffleWarning")
[17:26:40.151]                       }
[17:26:40.151]                       else if (inherits(cond, "condition")) {
[17:26:40.151]                         if (!is.null(pattern)) {
[17:26:40.151]                           computeRestarts <- base::computeRestarts
[17:26:40.151]                           grepl <- base::grepl
[17:26:40.151]                           restarts <- computeRestarts(cond)
[17:26:40.151]                           for (restart in restarts) {
[17:26:40.151]                             name <- restart$name
[17:26:40.151]                             if (is.null(name)) 
[17:26:40.151]                               next
[17:26:40.151]                             if (!grepl(pattern, name)) 
[17:26:40.151]                               next
[17:26:40.151]                             invokeRestart(restart)
[17:26:40.151]                             muffled <- TRUE
[17:26:40.151]                             break
[17:26:40.151]                           }
[17:26:40.151]                         }
[17:26:40.151]                       }
[17:26:40.151]                       invisible(muffled)
[17:26:40.151]                     }
[17:26:40.151]                     muffleCondition(cond, pattern = "^muffle")
[17:26:40.151]                   }
[17:26:40.151]                 }
[17:26:40.151]             }
[17:26:40.151]         }))
[17:26:40.151]     }, error = function(ex) {
[17:26:40.151]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:40.151]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:40.151]                 ...future.rng), started = ...future.startTime, 
[17:26:40.151]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:40.151]             version = "1.8"), class = "FutureResult")
[17:26:40.151]     }, finally = {
[17:26:40.151]         if (!identical(...future.workdir, getwd())) 
[17:26:40.151]             setwd(...future.workdir)
[17:26:40.151]         {
[17:26:40.151]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:40.151]                 ...future.oldOptions$nwarnings <- NULL
[17:26:40.151]             }
[17:26:40.151]             base::options(...future.oldOptions)
[17:26:40.151]             if (.Platform$OS.type == "windows") {
[17:26:40.151]                 old_names <- names(...future.oldEnvVars)
[17:26:40.151]                 envs <- base::Sys.getenv()
[17:26:40.151]                 names <- names(envs)
[17:26:40.151]                 common <- intersect(names, old_names)
[17:26:40.151]                 added <- setdiff(names, old_names)
[17:26:40.151]                 removed <- setdiff(old_names, names)
[17:26:40.151]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:40.151]                   envs[common]]
[17:26:40.151]                 NAMES <- toupper(changed)
[17:26:40.151]                 args <- list()
[17:26:40.151]                 for (kk in seq_along(NAMES)) {
[17:26:40.151]                   name <- changed[[kk]]
[17:26:40.151]                   NAME <- NAMES[[kk]]
[17:26:40.151]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:40.151]                     next
[17:26:40.151]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:40.151]                 }
[17:26:40.151]                 NAMES <- toupper(added)
[17:26:40.151]                 for (kk in seq_along(NAMES)) {
[17:26:40.151]                   name <- added[[kk]]
[17:26:40.151]                   NAME <- NAMES[[kk]]
[17:26:40.151]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:40.151]                     next
[17:26:40.151]                   args[[name]] <- ""
[17:26:40.151]                 }
[17:26:40.151]                 NAMES <- toupper(removed)
[17:26:40.151]                 for (kk in seq_along(NAMES)) {
[17:26:40.151]                   name <- removed[[kk]]
[17:26:40.151]                   NAME <- NAMES[[kk]]
[17:26:40.151]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:40.151]                     next
[17:26:40.151]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:40.151]                 }
[17:26:40.151]                 if (length(args) > 0) 
[17:26:40.151]                   base::do.call(base::Sys.setenv, args = args)
[17:26:40.151]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:40.151]             }
[17:26:40.151]             else {
[17:26:40.151]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:40.151]             }
[17:26:40.151]             {
[17:26:40.151]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:40.151]                   0L) {
[17:26:40.151]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:40.151]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:40.151]                   base::options(opts)
[17:26:40.151]                 }
[17:26:40.151]                 {
[17:26:40.151]                   {
[17:26:40.151]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:40.151]                     NULL
[17:26:40.151]                   }
[17:26:40.151]                   options(future.plan = NULL)
[17:26:40.151]                   if (is.na(NA_character_)) 
[17:26:40.151]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:40.151]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:40.151]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:40.151]                     .init = FALSE)
[17:26:40.151]                 }
[17:26:40.151]             }
[17:26:40.151]         }
[17:26:40.151]     })
[17:26:40.151]     if (TRUE) {
[17:26:40.151]         base::sink(type = "output", split = FALSE)
[17:26:40.151]         if (TRUE) {
[17:26:40.151]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:40.151]         }
[17:26:40.151]         else {
[17:26:40.151]             ...future.result["stdout"] <- base::list(NULL)
[17:26:40.151]         }
[17:26:40.151]         base::close(...future.stdout)
[17:26:40.151]         ...future.stdout <- NULL
[17:26:40.151]     }
[17:26:40.151]     ...future.result$conditions <- ...future.conditions
[17:26:40.151]     ...future.result$finished <- base::Sys.time()
[17:26:40.151]     ...future.result
[17:26:40.151] }
[17:26:40.165] Exporting 2 global objects (559 bytes) to cluster node #1 ...
[17:26:40.165] Exporting 'slow_fcn' (208 bytes) to cluster node #1 ...
[17:26:40.166] Exporting 'slow_fcn' (208 bytes) to cluster node #1 ... DONE
[17:26:40.166] Exporting 'x' (35 bytes) to cluster node #1 ...
[17:26:40.167] Exporting 'x' (35 bytes) to cluster node #1 ... DONE
[17:26:40.167] Exporting 2 global objects (559 bytes) to cluster node #1 ... DONE
[17:26:40.170] MultisessionFuture started
[17:26:40.171] - Launch lazy future ... done
[17:26:40.172] run() for 'MultisessionFuture' ... done
[17:26:40.174] getGlobalsAndPackages() ...
[17:26:40.175] Searching for globals...
[17:26:40.178] - globals found: [6] 'slow_fcn', 'x', '{', 'Sys.sleep', '+', '/'
[17:26:40.179] Searching for globals ... DONE
[17:26:40.179] Resolving globals: FALSE
[17:26:40.180] The total size of the 2 globals is 243 bytes (243 bytes)
[17:26:40.181] The total size of the 2 globals exported for future expression ('slow_fcn(x)') is 243 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'slow_fcn' (208 bytes of class 'function') and 'x' (35 bytes of class 'numeric')
[17:26:40.181] - globals: [2] 'slow_fcn', 'x'
[17:26:40.181] 
[17:26:40.182] getGlobalsAndPackages() ... DONE
[17:26:40.183] run() for 'Future' ...
[17:26:40.184] - state: 'created'
[17:26:40.184] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:40.206] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:40.206] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:40.207]   - Field: 'node'
[17:26:40.207]   - Field: 'label'
[17:26:40.207]   - Field: 'local'
[17:26:40.207]   - Field: 'owner'
[17:26:40.208]   - Field: 'envir'
[17:26:40.208]   - Field: 'workers'
[17:26:40.208]   - Field: 'packages'
[17:26:40.209]   - Field: 'gc'
[17:26:40.209]   - Field: 'conditions'
[17:26:40.209]   - Field: 'persistent'
[17:26:40.209]   - Field: 'expr'
[17:26:40.210]   - Field: 'uuid'
[17:26:40.210]   - Field: 'seed'
[17:26:40.210]   - Field: 'version'
[17:26:40.211]   - Field: 'result'
[17:26:40.211]   - Field: 'asynchronous'
[17:26:40.211]   - Field: 'calls'
[17:26:40.211]   - Field: 'globals'
[17:26:40.212]   - Field: 'stdout'
[17:26:40.212]   - Field: 'earlySignal'
[17:26:40.212]   - Field: 'lazy'
[17:26:40.213]   - Field: 'state'
[17:26:40.213] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:40.213] - Launch lazy future ...
[17:26:40.214] Packages needed by the future expression (n = 0): <none>
[17:26:40.214] Packages needed by future strategies (n = 0): <none>
[17:26:40.215] {
[17:26:40.215]     {
[17:26:40.215]         {
[17:26:40.215]             ...future.startTime <- base::Sys.time()
[17:26:40.215]             {
[17:26:40.215]                 {
[17:26:40.215]                   {
[17:26:40.215]                     {
[17:26:40.215]                       base::local({
[17:26:40.215]                         has_future <- base::requireNamespace("future", 
[17:26:40.215]                           quietly = TRUE)
[17:26:40.215]                         if (has_future) {
[17:26:40.215]                           ns <- base::getNamespace("future")
[17:26:40.215]                           version <- ns[[".package"]][["version"]]
[17:26:40.215]                           if (is.null(version)) 
[17:26:40.215]                             version <- utils::packageVersion("future")
[17:26:40.215]                         }
[17:26:40.215]                         else {
[17:26:40.215]                           version <- NULL
[17:26:40.215]                         }
[17:26:40.215]                         if (!has_future || version < "1.8.0") {
[17:26:40.215]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:40.215]                             "", base::R.version$version.string), 
[17:26:40.215]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:40.215]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:40.215]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:40.215]                               "release", "version")], collapse = " "), 
[17:26:40.215]                             hostname = base::Sys.info()[["nodename"]])
[17:26:40.215]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:40.215]                             info)
[17:26:40.215]                           info <- base::paste(info, collapse = "; ")
[17:26:40.215]                           if (!has_future) {
[17:26:40.215]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:40.215]                               info)
[17:26:40.215]                           }
[17:26:40.215]                           else {
[17:26:40.215]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:40.215]                               info, version)
[17:26:40.215]                           }
[17:26:40.215]                           base::stop(msg)
[17:26:40.215]                         }
[17:26:40.215]                       })
[17:26:40.215]                     }
[17:26:40.215]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:40.215]                     base::options(mc.cores = 1L)
[17:26:40.215]                   }
[17:26:40.215]                   ...future.strategy.old <- future::plan("list")
[17:26:40.215]                   options(future.plan = NULL)
[17:26:40.215]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:40.215]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:40.215]                 }
[17:26:40.215]                 ...future.workdir <- getwd()
[17:26:40.215]             }
[17:26:40.215]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:40.215]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:40.215]         }
[17:26:40.215]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:40.215]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:40.215]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:40.215]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:40.215]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:40.215]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:40.215]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:40.215]             base::names(...future.oldOptions))
[17:26:40.215]     }
[17:26:40.215]     if (FALSE) {
[17:26:40.215]     }
[17:26:40.215]     else {
[17:26:40.215]         if (TRUE) {
[17:26:40.215]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:40.215]                 open = "w")
[17:26:40.215]         }
[17:26:40.215]         else {
[17:26:40.215]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:40.215]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:40.215]         }
[17:26:40.215]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:40.215]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:40.215]             base::sink(type = "output", split = FALSE)
[17:26:40.215]             base::close(...future.stdout)
[17:26:40.215]         }, add = TRUE)
[17:26:40.215]     }
[17:26:40.215]     ...future.frame <- base::sys.nframe()
[17:26:40.215]     ...future.conditions <- base::list()
[17:26:40.215]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:40.215]     if (FALSE) {
[17:26:40.215]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:40.215]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:40.215]     }
[17:26:40.215]     ...future.result <- base::tryCatch({
[17:26:40.215]         base::withCallingHandlers({
[17:26:40.215]             ...future.value <- base::withVisible(base::local({
[17:26:40.215]                 ...future.makeSendCondition <- base::local({
[17:26:40.215]                   sendCondition <- NULL
[17:26:40.215]                   function(frame = 1L) {
[17:26:40.215]                     if (is.function(sendCondition)) 
[17:26:40.215]                       return(sendCondition)
[17:26:40.215]                     ns <- getNamespace("parallel")
[17:26:40.215]                     if (exists("sendData", mode = "function", 
[17:26:40.215]                       envir = ns)) {
[17:26:40.215]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:40.215]                         envir = ns)
[17:26:40.215]                       envir <- sys.frame(frame)
[17:26:40.215]                       master <- NULL
[17:26:40.215]                       while (!identical(envir, .GlobalEnv) && 
[17:26:40.215]                         !identical(envir, emptyenv())) {
[17:26:40.215]                         if (exists("master", mode = "list", envir = envir, 
[17:26:40.215]                           inherits = FALSE)) {
[17:26:40.215]                           master <- get("master", mode = "list", 
[17:26:40.215]                             envir = envir, inherits = FALSE)
[17:26:40.215]                           if (inherits(master, c("SOCKnode", 
[17:26:40.215]                             "SOCK0node"))) {
[17:26:40.215]                             sendCondition <<- function(cond) {
[17:26:40.215]                               data <- list(type = "VALUE", value = cond, 
[17:26:40.215]                                 success = TRUE)
[17:26:40.215]                               parallel_sendData(master, data)
[17:26:40.215]                             }
[17:26:40.215]                             return(sendCondition)
[17:26:40.215]                           }
[17:26:40.215]                         }
[17:26:40.215]                         frame <- frame + 1L
[17:26:40.215]                         envir <- sys.frame(frame)
[17:26:40.215]                       }
[17:26:40.215]                     }
[17:26:40.215]                     sendCondition <<- function(cond) NULL
[17:26:40.215]                   }
[17:26:40.215]                 })
[17:26:40.215]                 withCallingHandlers({
[17:26:40.215]                   slow_fcn(x)
[17:26:40.215]                 }, immediateCondition = function(cond) {
[17:26:40.215]                   sendCondition <- ...future.makeSendCondition()
[17:26:40.215]                   sendCondition(cond)
[17:26:40.215]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:40.215]                   {
[17:26:40.215]                     inherits <- base::inherits
[17:26:40.215]                     invokeRestart <- base::invokeRestart
[17:26:40.215]                     is.null <- base::is.null
[17:26:40.215]                     muffled <- FALSE
[17:26:40.215]                     if (inherits(cond, "message")) {
[17:26:40.215]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:40.215]                       if (muffled) 
[17:26:40.215]                         invokeRestart("muffleMessage")
[17:26:40.215]                     }
[17:26:40.215]                     else if (inherits(cond, "warning")) {
[17:26:40.215]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:40.215]                       if (muffled) 
[17:26:40.215]                         invokeRestart("muffleWarning")
[17:26:40.215]                     }
[17:26:40.215]                     else if (inherits(cond, "condition")) {
[17:26:40.215]                       if (!is.null(pattern)) {
[17:26:40.215]                         computeRestarts <- base::computeRestarts
[17:26:40.215]                         grepl <- base::grepl
[17:26:40.215]                         restarts <- computeRestarts(cond)
[17:26:40.215]                         for (restart in restarts) {
[17:26:40.215]                           name <- restart$name
[17:26:40.215]                           if (is.null(name)) 
[17:26:40.215]                             next
[17:26:40.215]                           if (!grepl(pattern, name)) 
[17:26:40.215]                             next
[17:26:40.215]                           invokeRestart(restart)
[17:26:40.215]                           muffled <- TRUE
[17:26:40.215]                           break
[17:26:40.215]                         }
[17:26:40.215]                       }
[17:26:40.215]                     }
[17:26:40.215]                     invisible(muffled)
[17:26:40.215]                   }
[17:26:40.215]                   muffleCondition(cond)
[17:26:40.215]                 })
[17:26:40.215]             }))
[17:26:40.215]             future::FutureResult(value = ...future.value$value, 
[17:26:40.215]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:40.215]                   ...future.rng), globalenv = if (FALSE) 
[17:26:40.215]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:40.215]                     ...future.globalenv.names))
[17:26:40.215]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:40.215]         }, condition = base::local({
[17:26:40.215]             c <- base::c
[17:26:40.215]             inherits <- base::inherits
[17:26:40.215]             invokeRestart <- base::invokeRestart
[17:26:40.215]             length <- base::length
[17:26:40.215]             list <- base::list
[17:26:40.215]             seq.int <- base::seq.int
[17:26:40.215]             signalCondition <- base::signalCondition
[17:26:40.215]             sys.calls <- base::sys.calls
[17:26:40.215]             `[[` <- base::`[[`
[17:26:40.215]             `+` <- base::`+`
[17:26:40.215]             `<<-` <- base::`<<-`
[17:26:40.215]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:40.215]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:40.215]                   3L)]
[17:26:40.215]             }
[17:26:40.215]             function(cond) {
[17:26:40.215]                 is_error <- inherits(cond, "error")
[17:26:40.215]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:40.215]                   NULL)
[17:26:40.215]                 if (is_error) {
[17:26:40.215]                   sessionInformation <- function() {
[17:26:40.215]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:40.215]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:40.215]                       search = base::search(), system = base::Sys.info())
[17:26:40.215]                   }
[17:26:40.215]                   ...future.conditions[[length(...future.conditions) + 
[17:26:40.215]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:40.215]                     cond$call), session = sessionInformation(), 
[17:26:40.215]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:40.215]                   signalCondition(cond)
[17:26:40.215]                 }
[17:26:40.215]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:40.215]                 "immediateCondition"))) {
[17:26:40.215]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:40.215]                   ...future.conditions[[length(...future.conditions) + 
[17:26:40.215]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:40.215]                   if (TRUE && !signal) {
[17:26:40.215]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:40.215]                     {
[17:26:40.215]                       inherits <- base::inherits
[17:26:40.215]                       invokeRestart <- base::invokeRestart
[17:26:40.215]                       is.null <- base::is.null
[17:26:40.215]                       muffled <- FALSE
[17:26:40.215]                       if (inherits(cond, "message")) {
[17:26:40.215]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:40.215]                         if (muffled) 
[17:26:40.215]                           invokeRestart("muffleMessage")
[17:26:40.215]                       }
[17:26:40.215]                       else if (inherits(cond, "warning")) {
[17:26:40.215]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:40.215]                         if (muffled) 
[17:26:40.215]                           invokeRestart("muffleWarning")
[17:26:40.215]                       }
[17:26:40.215]                       else if (inherits(cond, "condition")) {
[17:26:40.215]                         if (!is.null(pattern)) {
[17:26:40.215]                           computeRestarts <- base::computeRestarts
[17:26:40.215]                           grepl <- base::grepl
[17:26:40.215]                           restarts <- computeRestarts(cond)
[17:26:40.215]                           for (restart in restarts) {
[17:26:40.215]                             name <- restart$name
[17:26:40.215]                             if (is.null(name)) 
[17:26:40.215]                               next
[17:26:40.215]                             if (!grepl(pattern, name)) 
[17:26:40.215]                               next
[17:26:40.215]                             invokeRestart(restart)
[17:26:40.215]                             muffled <- TRUE
[17:26:40.215]                             break
[17:26:40.215]                           }
[17:26:40.215]                         }
[17:26:40.215]                       }
[17:26:40.215]                       invisible(muffled)
[17:26:40.215]                     }
[17:26:40.215]                     muffleCondition(cond, pattern = "^muffle")
[17:26:40.215]                   }
[17:26:40.215]                 }
[17:26:40.215]                 else {
[17:26:40.215]                   if (TRUE) {
[17:26:40.215]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:40.215]                     {
[17:26:40.215]                       inherits <- base::inherits
[17:26:40.215]                       invokeRestart <- base::invokeRestart
[17:26:40.215]                       is.null <- base::is.null
[17:26:40.215]                       muffled <- FALSE
[17:26:40.215]                       if (inherits(cond, "message")) {
[17:26:40.215]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:40.215]                         if (muffled) 
[17:26:40.215]                           invokeRestart("muffleMessage")
[17:26:40.215]                       }
[17:26:40.215]                       else if (inherits(cond, "warning")) {
[17:26:40.215]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:40.215]                         if (muffled) 
[17:26:40.215]                           invokeRestart("muffleWarning")
[17:26:40.215]                       }
[17:26:40.215]                       else if (inherits(cond, "condition")) {
[17:26:40.215]                         if (!is.null(pattern)) {
[17:26:40.215]                           computeRestarts <- base::computeRestarts
[17:26:40.215]                           grepl <- base::grepl
[17:26:40.215]                           restarts <- computeRestarts(cond)
[17:26:40.215]                           for (restart in restarts) {
[17:26:40.215]                             name <- restart$name
[17:26:40.215]                             if (is.null(name)) 
[17:26:40.215]                               next
[17:26:40.215]                             if (!grepl(pattern, name)) 
[17:26:40.215]                               next
[17:26:40.215]                             invokeRestart(restart)
[17:26:40.215]                             muffled <- TRUE
[17:26:40.215]                             break
[17:26:40.215]                           }
[17:26:40.215]                         }
[17:26:40.215]                       }
[17:26:40.215]                       invisible(muffled)
[17:26:40.215]                     }
[17:26:40.215]                     muffleCondition(cond, pattern = "^muffle")
[17:26:40.215]                   }
[17:26:40.215]                 }
[17:26:40.215]             }
[17:26:40.215]         }))
[17:26:40.215]     }, error = function(ex) {
[17:26:40.215]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:40.215]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:40.215]                 ...future.rng), started = ...future.startTime, 
[17:26:40.215]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:40.215]             version = "1.8"), class = "FutureResult")
[17:26:40.215]     }, finally = {
[17:26:40.215]         if (!identical(...future.workdir, getwd())) 
[17:26:40.215]             setwd(...future.workdir)
[17:26:40.215]         {
[17:26:40.215]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:40.215]                 ...future.oldOptions$nwarnings <- NULL
[17:26:40.215]             }
[17:26:40.215]             base::options(...future.oldOptions)
[17:26:40.215]             if (.Platform$OS.type == "windows") {
[17:26:40.215]                 old_names <- names(...future.oldEnvVars)
[17:26:40.215]                 envs <- base::Sys.getenv()
[17:26:40.215]                 names <- names(envs)
[17:26:40.215]                 common <- intersect(names, old_names)
[17:26:40.215]                 added <- setdiff(names, old_names)
[17:26:40.215]                 removed <- setdiff(old_names, names)
[17:26:40.215]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:40.215]                   envs[common]]
[17:26:40.215]                 NAMES <- toupper(changed)
[17:26:40.215]                 args <- list()
[17:26:40.215]                 for (kk in seq_along(NAMES)) {
[17:26:40.215]                   name <- changed[[kk]]
[17:26:40.215]                   NAME <- NAMES[[kk]]
[17:26:40.215]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:40.215]                     next
[17:26:40.215]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:40.215]                 }
[17:26:40.215]                 NAMES <- toupper(added)
[17:26:40.215]                 for (kk in seq_along(NAMES)) {
[17:26:40.215]                   name <- added[[kk]]
[17:26:40.215]                   NAME <- NAMES[[kk]]
[17:26:40.215]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:40.215]                     next
[17:26:40.215]                   args[[name]] <- ""
[17:26:40.215]                 }
[17:26:40.215]                 NAMES <- toupper(removed)
[17:26:40.215]                 for (kk in seq_along(NAMES)) {
[17:26:40.215]                   name <- removed[[kk]]
[17:26:40.215]                   NAME <- NAMES[[kk]]
[17:26:40.215]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:40.215]                     next
[17:26:40.215]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:40.215]                 }
[17:26:40.215]                 if (length(args) > 0) 
[17:26:40.215]                   base::do.call(base::Sys.setenv, args = args)
[17:26:40.215]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:40.215]             }
[17:26:40.215]             else {
[17:26:40.215]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:40.215]             }
[17:26:40.215]             {
[17:26:40.215]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:40.215]                   0L) {
[17:26:40.215]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:40.215]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:40.215]                   base::options(opts)
[17:26:40.215]                 }
[17:26:40.215]                 {
[17:26:40.215]                   {
[17:26:40.215]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:40.215]                     NULL
[17:26:40.215]                   }
[17:26:40.215]                   options(future.plan = NULL)
[17:26:40.215]                   if (is.na(NA_character_)) 
[17:26:40.215]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:40.215]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:40.215]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:40.215]                     .init = FALSE)
[17:26:40.215]                 }
[17:26:40.215]             }
[17:26:40.215]         }
[17:26:40.215]     })
[17:26:40.215]     if (TRUE) {
[17:26:40.215]         base::sink(type = "output", split = FALSE)
[17:26:40.215]         if (TRUE) {
[17:26:40.215]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:40.215]         }
[17:26:40.215]         else {
[17:26:40.215]             ...future.result["stdout"] <- base::list(NULL)
[17:26:40.215]         }
[17:26:40.215]         base::close(...future.stdout)
[17:26:40.215]         ...future.stdout <- NULL
[17:26:40.215]     }
[17:26:40.215]     ...future.result$conditions <- ...future.conditions
[17:26:40.215]     ...future.result$finished <- base::Sys.time()
[17:26:40.215]     ...future.result
[17:26:40.215] }
[17:26:40.378] Exporting 2 global objects (559 bytes) to cluster node #2 ...
[17:26:40.379] Exporting 'slow_fcn' (208 bytes) to cluster node #2 ...
[17:26:40.379] Exporting 'slow_fcn' (208 bytes) to cluster node #2 ... DONE
[17:26:40.380] Exporting 'x' (35 bytes) to cluster node #2 ...
[17:26:40.380] Exporting 'x' (35 bytes) to cluster node #2 ... DONE
[17:26:40.380] Exporting 2 global objects (559 bytes) to cluster node #2 ... DONE
[17:26:40.382] MultisessionFuture started
[17:26:40.383] - Launch lazy future ... done
[17:26:40.383] run() for 'MultisessionFuture' ... done
[17:26:40.383] getGlobalsAndPackages() ...
[17:26:40.384] Searching for globals...
[17:26:40.386] - globals found: [6] 'slow_fcn', 'x', '{', 'Sys.sleep', '+', '/'
[17:26:40.386] Searching for globals ... DONE
[17:26:40.386] Resolving globals: FALSE
[17:26:40.387] The total size of the 2 globals is 243 bytes (243 bytes)
[17:26:40.387] The total size of the 2 globals exported for future expression ('slow_fcn(x)') is 243 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'slow_fcn' (208 bytes of class 'function') and 'x' (35 bytes of class 'numeric')
[17:26:40.387] - globals: [2] 'slow_fcn', 'x'
[17:26:40.387] 
[17:26:40.388] getGlobalsAndPackages() ... DONE
[17:26:40.388] run() for 'Future' ...
[17:26:40.389] - state: 'created'
[17:26:40.389] - Future backend: 'FutureStrategy', 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:40.404] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:40.404] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:40.404]   - Field: 'node'
[17:26:40.405]   - Field: 'label'
[17:26:40.405]   - Field: 'local'
[17:26:40.405]   - Field: 'owner'
[17:26:40.405]   - Field: 'envir'
[17:26:40.405]   - Field: 'workers'
[17:26:40.405]   - Field: 'packages'
[17:26:40.406]   - Field: 'gc'
[17:26:40.406]   - Field: 'conditions'
[17:26:40.406]   - Field: 'persistent'
[17:26:40.406]   - Field: 'expr'
[17:26:40.407]   - Field: 'uuid'
[17:26:40.407]   - Field: 'seed'
[17:26:40.407]   - Field: 'version'
[17:26:40.407]   - Field: 'result'
[17:26:40.407]   - Field: 'asynchronous'
[17:26:40.408]   - Field: 'calls'
[17:26:40.408]   - Field: 'globals'
[17:26:40.408]   - Field: 'stdout'
[17:26:40.408]   - Field: 'earlySignal'
[17:26:40.408]   - Field: 'lazy'
[17:26:40.408]   - Field: 'state'
[17:26:40.409] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:40.409] - Launch lazy future ...
[17:26:40.409] Packages needed by the future expression (n = 0): <none>
[17:26:40.409] Packages needed by future strategies (n = 0): <none>
[17:26:40.410] {
[17:26:40.410]     {
[17:26:40.410]         {
[17:26:40.410]             ...future.startTime <- base::Sys.time()
[17:26:40.410]             {
[17:26:40.410]                 {
[17:26:40.410]                   {
[17:26:40.410]                     {
[17:26:40.410]                       base::local({
[17:26:40.410]                         has_future <- base::requireNamespace("future", 
[17:26:40.410]                           quietly = TRUE)
[17:26:40.410]                         if (has_future) {
[17:26:40.410]                           ns <- base::getNamespace("future")
[17:26:40.410]                           version <- ns[[".package"]][["version"]]
[17:26:40.410]                           if (is.null(version)) 
[17:26:40.410]                             version <- utils::packageVersion("future")
[17:26:40.410]                         }
[17:26:40.410]                         else {
[17:26:40.410]                           version <- NULL
[17:26:40.410]                         }
[17:26:40.410]                         if (!has_future || version < "1.8.0") {
[17:26:40.410]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:40.410]                             "", base::R.version$version.string), 
[17:26:40.410]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:40.410]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:40.410]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:40.410]                               "release", "version")], collapse = " "), 
[17:26:40.410]                             hostname = base::Sys.info()[["nodename"]])
[17:26:40.410]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:40.410]                             info)
[17:26:40.410]                           info <- base::paste(info, collapse = "; ")
[17:26:40.410]                           if (!has_future) {
[17:26:40.410]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:40.410]                               info)
[17:26:40.410]                           }
[17:26:40.410]                           else {
[17:26:40.410]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:40.410]                               info, version)
[17:26:40.410]                           }
[17:26:40.410]                           base::stop(msg)
[17:26:40.410]                         }
[17:26:40.410]                       })
[17:26:40.410]                     }
[17:26:40.410]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:40.410]                     base::options(mc.cores = 1L)
[17:26:40.410]                   }
[17:26:40.410]                   ...future.strategy.old <- future::plan("list")
[17:26:40.410]                   options(future.plan = NULL)
[17:26:40.410]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:40.410]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:40.410]                 }
[17:26:40.410]                 ...future.workdir <- getwd()
[17:26:40.410]             }
[17:26:40.410]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:40.410]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:40.410]         }
[17:26:40.410]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:40.410]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:40.410]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:40.410]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:40.410]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:40.410]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:40.410]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:40.410]             base::names(...future.oldOptions))
[17:26:40.410]     }
[17:26:40.410]     if (FALSE) {
[17:26:40.410]     }
[17:26:40.410]     else {
[17:26:40.410]         if (TRUE) {
[17:26:40.410]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:40.410]                 open = "w")
[17:26:40.410]         }
[17:26:40.410]         else {
[17:26:40.410]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:40.410]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:40.410]         }
[17:26:40.410]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:40.410]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:40.410]             base::sink(type = "output", split = FALSE)
[17:26:40.410]             base::close(...future.stdout)
[17:26:40.410]         }, add = TRUE)
[17:26:40.410]     }
[17:26:40.410]     ...future.frame <- base::sys.nframe()
[17:26:40.410]     ...future.conditions <- base::list()
[17:26:40.410]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:40.410]     if (FALSE) {
[17:26:40.410]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:40.410]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:40.410]     }
[17:26:40.410]     ...future.result <- base::tryCatch({
[17:26:40.410]         base::withCallingHandlers({
[17:26:40.410]             ...future.value <- base::withVisible(base::local({
[17:26:40.410]                 ...future.makeSendCondition <- base::local({
[17:26:40.410]                   sendCondition <- NULL
[17:26:40.410]                   function(frame = 1L) {
[17:26:40.410]                     if (is.function(sendCondition)) 
[17:26:40.410]                       return(sendCondition)
[17:26:40.410]                     ns <- getNamespace("parallel")
[17:26:40.410]                     if (exists("sendData", mode = "function", 
[17:26:40.410]                       envir = ns)) {
[17:26:40.410]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:40.410]                         envir = ns)
[17:26:40.410]                       envir <- sys.frame(frame)
[17:26:40.410]                       master <- NULL
[17:26:40.410]                       while (!identical(envir, .GlobalEnv) && 
[17:26:40.410]                         !identical(envir, emptyenv())) {
[17:26:40.410]                         if (exists("master", mode = "list", envir = envir, 
[17:26:40.410]                           inherits = FALSE)) {
[17:26:40.410]                           master <- get("master", mode = "list", 
[17:26:40.410]                             envir = envir, inherits = FALSE)
[17:26:40.410]                           if (inherits(master, c("SOCKnode", 
[17:26:40.410]                             "SOCK0node"))) {
[17:26:40.410]                             sendCondition <<- function(cond) {
[17:26:40.410]                               data <- list(type = "VALUE", value = cond, 
[17:26:40.410]                                 success = TRUE)
[17:26:40.410]                               parallel_sendData(master, data)
[17:26:40.410]                             }
[17:26:40.410]                             return(sendCondition)
[17:26:40.410]                           }
[17:26:40.410]                         }
[17:26:40.410]                         frame <- frame + 1L
[17:26:40.410]                         envir <- sys.frame(frame)
[17:26:40.410]                       }
[17:26:40.410]                     }
[17:26:40.410]                     sendCondition <<- function(cond) NULL
[17:26:40.410]                   }
[17:26:40.410]                 })
[17:26:40.410]                 withCallingHandlers({
[17:26:40.410]                   slow_fcn(x)
[17:26:40.410]                 }, immediateCondition = function(cond) {
[17:26:40.410]                   sendCondition <- ...future.makeSendCondition()
[17:26:40.410]                   sendCondition(cond)
[17:26:40.410]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:40.410]                   {
[17:26:40.410]                     inherits <- base::inherits
[17:26:40.410]                     invokeRestart <- base::invokeRestart
[17:26:40.410]                     is.null <- base::is.null
[17:26:40.410]                     muffled <- FALSE
[17:26:40.410]                     if (inherits(cond, "message")) {
[17:26:40.410]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:40.410]                       if (muffled) 
[17:26:40.410]                         invokeRestart("muffleMessage")
[17:26:40.410]                     }
[17:26:40.410]                     else if (inherits(cond, "warning")) {
[17:26:40.410]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:40.410]                       if (muffled) 
[17:26:40.410]                         invokeRestart("muffleWarning")
[17:26:40.410]                     }
[17:26:40.410]                     else if (inherits(cond, "condition")) {
[17:26:40.410]                       if (!is.null(pattern)) {
[17:26:40.410]                         computeRestarts <- base::computeRestarts
[17:26:40.410]                         grepl <- base::grepl
[17:26:40.410]                         restarts <- computeRestarts(cond)
[17:26:40.410]                         for (restart in restarts) {
[17:26:40.410]                           name <- restart$name
[17:26:40.410]                           if (is.null(name)) 
[17:26:40.410]                             next
[17:26:40.410]                           if (!grepl(pattern, name)) 
[17:26:40.410]                             next
[17:26:40.410]                           invokeRestart(restart)
[17:26:40.410]                           muffled <- TRUE
[17:26:40.410]                           break
[17:26:40.410]                         }
[17:26:40.410]                       }
[17:26:40.410]                     }
[17:26:40.410]                     invisible(muffled)
[17:26:40.410]                   }
[17:26:40.410]                   muffleCondition(cond)
[17:26:40.410]                 })
[17:26:40.410]             }))
[17:26:40.410]             future::FutureResult(value = ...future.value$value, 
[17:26:40.410]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:40.410]                   ...future.rng), globalenv = if (FALSE) 
[17:26:40.410]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:40.410]                     ...future.globalenv.names))
[17:26:40.410]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:40.410]         }, condition = base::local({
[17:26:40.410]             c <- base::c
[17:26:40.410]             inherits <- base::inherits
[17:26:40.410]             invokeRestart <- base::invokeRestart
[17:26:40.410]             length <- base::length
[17:26:40.410]             list <- base::list
[17:26:40.410]             seq.int <- base::seq.int
[17:26:40.410]             signalCondition <- base::signalCondition
[17:26:40.410]             sys.calls <- base::sys.calls
[17:26:40.410]             `[[` <- base::`[[`
[17:26:40.410]             `+` <- base::`+`
[17:26:40.410]             `<<-` <- base::`<<-`
[17:26:40.410]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:40.410]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:40.410]                   3L)]
[17:26:40.410]             }
[17:26:40.410]             function(cond) {
[17:26:40.410]                 is_error <- inherits(cond, "error")
[17:26:40.410]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:40.410]                   NULL)
[17:26:40.410]                 if (is_error) {
[17:26:40.410]                   sessionInformation <- function() {
[17:26:40.410]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:40.410]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:40.410]                       search = base::search(), system = base::Sys.info())
[17:26:40.410]                   }
[17:26:40.410]                   ...future.conditions[[length(...future.conditions) + 
[17:26:40.410]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:40.410]                     cond$call), session = sessionInformation(), 
[17:26:40.410]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:40.410]                   signalCondition(cond)
[17:26:40.410]                 }
[17:26:40.410]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:40.410]                 "immediateCondition"))) {
[17:26:40.410]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:40.410]                   ...future.conditions[[length(...future.conditions) + 
[17:26:40.410]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:40.410]                   if (TRUE && !signal) {
[17:26:40.410]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:40.410]                     {
[17:26:40.410]                       inherits <- base::inherits
[17:26:40.410]                       invokeRestart <- base::invokeRestart
[17:26:40.410]                       is.null <- base::is.null
[17:26:40.410]                       muffled <- FALSE
[17:26:40.410]                       if (inherits(cond, "message")) {
[17:26:40.410]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:40.410]                         if (muffled) 
[17:26:40.410]                           invokeRestart("muffleMessage")
[17:26:40.410]                       }
[17:26:40.410]                       else if (inherits(cond, "warning")) {
[17:26:40.410]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:40.410]                         if (muffled) 
[17:26:40.410]                           invokeRestart("muffleWarning")
[17:26:40.410]                       }
[17:26:40.410]                       else if (inherits(cond, "condition")) {
[17:26:40.410]                         if (!is.null(pattern)) {
[17:26:40.410]                           computeRestarts <- base::computeRestarts
[17:26:40.410]                           grepl <- base::grepl
[17:26:40.410]                           restarts <- computeRestarts(cond)
[17:26:40.410]                           for (restart in restarts) {
[17:26:40.410]                             name <- restart$name
[17:26:40.410]                             if (is.null(name)) 
[17:26:40.410]                               next
[17:26:40.410]                             if (!grepl(pattern, name)) 
[17:26:40.410]                               next
[17:26:40.410]                             invokeRestart(restart)
[17:26:40.410]                             muffled <- TRUE
[17:26:40.410]                             break
[17:26:40.410]                           }
[17:26:40.410]                         }
[17:26:40.410]                       }
[17:26:40.410]                       invisible(muffled)
[17:26:40.410]                     }
[17:26:40.410]                     muffleCondition(cond, pattern = "^muffle")
[17:26:40.410]                   }
[17:26:40.410]                 }
[17:26:40.410]                 else {
[17:26:40.410]                   if (TRUE) {
[17:26:40.410]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:40.410]                     {
[17:26:40.410]                       inherits <- base::inherits
[17:26:40.410]                       invokeRestart <- base::invokeRestart
[17:26:40.410]                       is.null <- base::is.null
[17:26:40.410]                       muffled <- FALSE
[17:26:40.410]                       if (inherits(cond, "message")) {
[17:26:40.410]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:40.410]                         if (muffled) 
[17:26:40.410]                           invokeRestart("muffleMessage")
[17:26:40.410]                       }
[17:26:40.410]                       else if (inherits(cond, "warning")) {
[17:26:40.410]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:40.410]                         if (muffled) 
[17:26:40.410]                           invokeRestart("muffleWarning")
[17:26:40.410]                       }
[17:26:40.410]                       else if (inherits(cond, "condition")) {
[17:26:40.410]                         if (!is.null(pattern)) {
[17:26:40.410]                           computeRestarts <- base::computeRestarts
[17:26:40.410]                           grepl <- base::grepl
[17:26:40.410]                           restarts <- computeRestarts(cond)
[17:26:40.410]                           for (restart in restarts) {
[17:26:40.410]                             name <- restart$name
[17:26:40.410]                             if (is.null(name)) 
[17:26:40.410]                               next
[17:26:40.410]                             if (!grepl(pattern, name)) 
[17:26:40.410]                               next
[17:26:40.410]                             invokeRestart(restart)
[17:26:40.410]                             muffled <- TRUE
[17:26:40.410]                             break
[17:26:40.410]                           }
[17:26:40.410]                         }
[17:26:40.410]                       }
[17:26:40.410]                       invisible(muffled)
[17:26:40.410]                     }
[17:26:40.410]                     muffleCondition(cond, pattern = "^muffle")
[17:26:40.410]                   }
[17:26:40.410]                 }
[17:26:40.410]             }
[17:26:40.410]         }))
[17:26:40.410]     }, error = function(ex) {
[17:26:40.410]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:40.410]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:40.410]                 ...future.rng), started = ...future.startTime, 
[17:26:40.410]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:40.410]             version = "1.8"), class = "FutureResult")
[17:26:40.410]     }, finally = {
[17:26:40.410]         if (!identical(...future.workdir, getwd())) 
[17:26:40.410]             setwd(...future.workdir)
[17:26:40.410]         {
[17:26:40.410]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:40.410]                 ...future.oldOptions$nwarnings <- NULL
[17:26:40.410]             }
[17:26:40.410]             base::options(...future.oldOptions)
[17:26:40.410]             if (.Platform$OS.type == "windows") {
[17:26:40.410]                 old_names <- names(...future.oldEnvVars)
[17:26:40.410]                 envs <- base::Sys.getenv()
[17:26:40.410]                 names <- names(envs)
[17:26:40.410]                 common <- intersect(names, old_names)
[17:26:40.410]                 added <- setdiff(names, old_names)
[17:26:40.410]                 removed <- setdiff(old_names, names)
[17:26:40.410]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:40.410]                   envs[common]]
[17:26:40.410]                 NAMES <- toupper(changed)
[17:26:40.410]                 args <- list()
[17:26:40.410]                 for (kk in seq_along(NAMES)) {
[17:26:40.410]                   name <- changed[[kk]]
[17:26:40.410]                   NAME <- NAMES[[kk]]
[17:26:40.410]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:40.410]                     next
[17:26:40.410]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:40.410]                 }
[17:26:40.410]                 NAMES <- toupper(added)
[17:26:40.410]                 for (kk in seq_along(NAMES)) {
[17:26:40.410]                   name <- added[[kk]]
[17:26:40.410]                   NAME <- NAMES[[kk]]
[17:26:40.410]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:40.410]                     next
[17:26:40.410]                   args[[name]] <- ""
[17:26:40.410]                 }
[17:26:40.410]                 NAMES <- toupper(removed)
[17:26:40.410]                 for (kk in seq_along(NAMES)) {
[17:26:40.410]                   name <- removed[[kk]]
[17:26:40.410]                   NAME <- NAMES[[kk]]
[17:26:40.410]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:40.410]                     next
[17:26:40.410]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:40.410]                 }
[17:26:40.410]                 if (length(args) > 0) 
[17:26:40.410]                   base::do.call(base::Sys.setenv, args = args)
[17:26:40.410]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:40.410]             }
[17:26:40.410]             else {
[17:26:40.410]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:40.410]             }
[17:26:40.410]             {
[17:26:40.410]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:40.410]                   0L) {
[17:26:40.410]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:40.410]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:40.410]                   base::options(opts)
[17:26:40.410]                 }
[17:26:40.410]                 {
[17:26:40.410]                   {
[17:26:40.410]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:40.410]                     NULL
[17:26:40.410]                   }
[17:26:40.410]                   options(future.plan = NULL)
[17:26:40.410]                   if (is.na(NA_character_)) 
[17:26:40.410]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:40.410]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:40.410]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:40.410]                     .init = FALSE)
[17:26:40.410]                 }
[17:26:40.410]             }
[17:26:40.410]         }
[17:26:40.410]     })
[17:26:40.410]     if (TRUE) {
[17:26:40.410]         base::sink(type = "output", split = FALSE)
[17:26:40.410]         if (TRUE) {
[17:26:40.410]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:40.410]         }
[17:26:40.410]         else {
[17:26:40.410]             ...future.result["stdout"] <- base::list(NULL)
[17:26:40.410]         }
[17:26:40.410]         base::close(...future.stdout)
[17:26:40.410]         ...future.stdout <- NULL
[17:26:40.410]     }
[17:26:40.410]     ...future.result$conditions <- ...future.conditions
[17:26:40.410]     ...future.result$finished <- base::Sys.time()
[17:26:40.410]     ...future.result
[17:26:40.410] }
[17:26:40.417] Poll #1 (0): usedNodes() = 2, workers = 2
[17:26:40.844] Poll #2 (0.43 secs): usedNodes() = 2, workers = 2
[17:26:41.044] receiveMessageFromWorker() for ClusterFuture ...
[17:26:41.044] - Validating connection of MultisessionFuture
[17:26:41.045] - received message: FutureResult
[17:26:41.046] - Received FutureResult
[17:26:41.046] - Erased future from FutureRegistry
[17:26:41.047] result() for ClusterFuture ...
[17:26:41.047] - result already collected: FutureResult
[17:26:41.048] result() for ClusterFuture ... done
[17:26:41.054] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:41.055] result() for ClusterFuture ...
[17:26:41.055] - result already collected: FutureResult
[17:26:41.055] result() for ClusterFuture ... done
[17:26:41.056] result() for ClusterFuture ...
[17:26:41.056] - result already collected: FutureResult
[17:26:41.056] result() for ClusterFuture ... done
[17:26:41.061] Exporting 2 global objects (559 bytes) to cluster node #1 ...
[17:26:41.062] Exporting 'slow_fcn' (208 bytes) to cluster node #1 ...
[17:26:41.062] Exporting 'slow_fcn' (208 bytes) to cluster node #1 ... DONE
[17:26:41.063] Exporting 'x' (35 bytes) to cluster node #1 ...
[17:26:41.063] Exporting 'x' (35 bytes) to cluster node #1 ... DONE
[17:26:41.064] Exporting 2 global objects (559 bytes) to cluster node #1 ... DONE
[17:26:41.066] MultisessionFuture started
[17:26:41.067] - Launch lazy future ... done
[17:26:41.067] run() for 'MultisessionFuture' ... done
[17:26:41.068] resolve() on list ...
[17:26:41.068]  recursive: 0
[17:26:41.069]  length: 3
[17:26:41.069] 
[17:26:41.069] Future #1
[17:26:41.070] result() for ClusterFuture ...
[17:26:41.070] - result already collected: FutureResult
[17:26:41.070] result() for ClusterFuture ... done
[17:26:41.070] result() for ClusterFuture ...
[17:26:41.071] - result already collected: FutureResult
[17:26:41.071] result() for ClusterFuture ... done
[17:26:41.071] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:26:41.071] - nx: 3
[17:26:41.072] - relay: TRUE
[17:26:41.072] - stdout: TRUE
[17:26:41.072] - signal: TRUE
[17:26:41.072] - resignal: FALSE
[17:26:41.073] - force: TRUE
[17:26:41.073] - relayed: [n=3] FALSE, FALSE, FALSE
[17:26:41.073] - queued futures: [n=3] FALSE, FALSE, FALSE
[17:26:41.073]  - until=1
[17:26:41.074]  - relaying element #1
[17:26:41.074] result() for ClusterFuture ...
[17:26:41.074] - result already collected: FutureResult
[17:26:41.074] result() for ClusterFuture ... done
[17:26:41.075] result() for ClusterFuture ...
[17:26:41.075] - result already collected: FutureResult
[17:26:41.075] result() for ClusterFuture ... done
[17:26:41.075] result() for ClusterFuture ...
[17:26:41.076] - result already collected: FutureResult
[17:26:41.076] result() for ClusterFuture ... done
[17:26:41.076] result() for ClusterFuture ...
[17:26:41.076] - result already collected: FutureResult
[17:26:41.077] result() for ClusterFuture ... done
[17:26:41.077] - relayed: [n=3] TRUE, FALSE, FALSE
[17:26:41.077] - queued futures: [n=3] TRUE, FALSE, FALSE
[17:26:41.077] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[17:26:41.078]  length: 2 (resolved future 1)
[17:26:41.501] receiveMessageFromWorker() for ClusterFuture ...
[17:26:41.501] - Validating connection of MultisessionFuture
[17:26:41.502] - received message: FutureResult
[17:26:41.503] - Received FutureResult
[17:26:41.503] - Erased future from FutureRegistry
[17:26:41.504] result() for ClusterFuture ...
[17:26:41.504] - result already collected: FutureResult
[17:26:41.504] result() for ClusterFuture ... done
[17:26:41.507] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:41.507] Future #2
[17:26:41.507] result() for ClusterFuture ...
[17:26:41.507] - result already collected: FutureResult
[17:26:41.507] result() for ClusterFuture ... done
[17:26:41.508] result() for ClusterFuture ...
[17:26:41.508] - result already collected: FutureResult
[17:26:41.508] result() for ClusterFuture ... done
[17:26:41.508] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:26:41.508] - nx: 3
[17:26:41.509] - relay: TRUE
[17:26:41.509] - stdout: TRUE
[17:26:41.509] - signal: TRUE
[17:26:41.509] - resignal: FALSE
[17:26:41.509] - force: TRUE
[17:26:41.509] - relayed: [n=3] TRUE, FALSE, FALSE
[17:26:41.510] - queued futures: [n=3] TRUE, FALSE, FALSE
[17:26:41.510]  - until=2
[17:26:41.510]  - relaying element #2
[17:26:41.510] result() for ClusterFuture ...
[17:26:41.510] - result already collected: FutureResult
[17:26:41.510] result() for ClusterFuture ... done
[17:26:41.511] result() for ClusterFuture ...
[17:26:41.511] - result already collected: FutureResult
[17:26:41.511] result() for ClusterFuture ... done
[17:26:41.511] result() for ClusterFuture ...
[17:26:41.511] - result already collected: FutureResult
[17:26:41.511] result() for ClusterFuture ... done
[17:26:41.512] result() for ClusterFuture ...
[17:26:41.512] - result already collected: FutureResult
[17:26:41.512] result() for ClusterFuture ... done
[17:26:41.512] - relayed: [n=3] TRUE, TRUE, FALSE
[17:26:41.512] - queued futures: [n=3] TRUE, TRUE, FALSE
[17:26:41.513] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:26:41.513]  length: 1 (resolved future 2)
[17:26:42.634] receiveMessageFromWorker() for ClusterFuture ...
[17:26:42.634] - Validating connection of MultisessionFuture
[17:26:42.635] - received message: FutureResult
[17:26:42.636] - Received FutureResult
[17:26:42.636] - Erased future from FutureRegistry
[17:26:42.636] result() for ClusterFuture ...
[17:26:42.637] - result already collected: FutureResult
[17:26:42.637] result() for ClusterFuture ... done
[17:26:42.640] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:42.640] Future #3
[17:26:42.640] result() for ClusterFuture ...
[17:26:42.640] - result already collected: FutureResult
[17:26:42.644] result() for ClusterFuture ... done
[17:26:42.644] result() for ClusterFuture ...
[17:26:42.644] - result already collected: FutureResult
[17:26:42.645] result() for ClusterFuture ... done
[17:26:42.645] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:26:42.645] - nx: 3
[17:26:42.646] - relay: TRUE
[17:26:42.646] - stdout: TRUE
[17:26:42.646] - signal: TRUE
[17:26:42.646] - resignal: FALSE
[17:26:42.647] - force: TRUE
[17:26:42.647] - relayed: [n=3] TRUE, TRUE, FALSE
[17:26:42.647] - queued futures: [n=3] TRUE, TRUE, FALSE
[17:26:42.647]  - until=3
[17:26:42.648]  - relaying element #3
[17:26:42.648] result() for ClusterFuture ...
[17:26:42.648] - result already collected: FutureResult
[17:26:42.648] result() for ClusterFuture ... done
[17:26:42.649] result() for ClusterFuture ...
[17:26:42.649] - result already collected: FutureResult
[17:26:42.649] result() for ClusterFuture ... done
[17:26:42.650] result() for ClusterFuture ...
[17:26:42.650] - result already collected: FutureResult
[17:26:42.650] result() for ClusterFuture ... done
[17:26:42.650] result() for ClusterFuture ...
[17:26:42.651] - result already collected: FutureResult
[17:26:42.651] result() for ClusterFuture ... done
[17:26:42.651] - relayed: [n=3] TRUE, TRUE, TRUE
[17:26:42.651] - queued futures: [n=3] TRUE, TRUE, TRUE
[17:26:42.652] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:26:42.652]  length: 0 (resolved future 3)
[17:26:42.652] Relaying remaining futures
[17:26:42.652] signalConditionsASAP(NULL, pos=0) ...
[17:26:42.653] - nx: 3
[17:26:42.653] - relay: TRUE
[17:26:42.653] - stdout: TRUE
[17:26:42.653] - signal: TRUE
[17:26:42.654] - resignal: FALSE
[17:26:42.654] - force: TRUE
[17:26:42.654] - relayed: [n=3] TRUE, TRUE, TRUE
[17:26:42.654] - queued futures: [n=3] TRUE, TRUE, TRUE
 - flush all
[17:26:42.655] - relayed: [n=3] TRUE, TRUE, TRUE
[17:26:42.655] - queued futures: [n=3] TRUE, TRUE, TRUE
[17:26:42.655] signalConditionsASAP(NULL, pos=0) ... done
[17:26:42.656] resolve() on list ... DONE
[17:26:42.656] result() for ClusterFuture ...
[17:26:42.656] - result already collected: FutureResult
[17:26:42.656] result() for ClusterFuture ... done
[17:26:42.657] result() for ClusterFuture ...
[17:26:42.657] - result already collected: FutureResult
[17:26:42.657] result() for ClusterFuture ... done
[17:26:42.657] result() for ClusterFuture ...
[17:26:42.657] - result already collected: FutureResult
[17:26:42.657] result() for ClusterFuture ... done
[17:26:42.658] result() for ClusterFuture ...
[17:26:42.658] - result already collected: FutureResult
[17:26:42.658] result() for ClusterFuture ... done
[17:26:42.658] result() for ClusterFuture ...
[17:26:42.658] - result already collected: FutureResult
[17:26:42.658] result() for ClusterFuture ... done
[17:26:42.659] result() for ClusterFuture ...
[17:26:42.659] - result already collected: FutureResult
[17:26:42.659] result() for ClusterFuture ... done
> print(js)
[[1]]
           event   category parent               start              at
1         create   overhead   <NA> 2024-07-29 17:26:40 0.00000000 secs
6         launch   overhead   <NA> 2024-07-29 17:26:40 0.04578614 secs
2      getWorker   overhead launch 2024-07-29 17:26:40 0.05563402 secs
3    eraseWorker   overhead launch 2024-07-29 17:26:40 0.05833793 secs
4 attachPackages   overhead launch 2024-07-29 17:26:40 0.06034493 secs
5  exportGlobals   overhead launch 2024-07-29 17:26:40 0.06165600 secs
9       evaluate evaluation   <NA> 2024-07-29 17:26:40 0.06697392 secs
7  receiveResult   overhead gather 2024-07-29 17:26:41 0.94151592 secs
8         gather   overhead   <NA> 2024-07-29 17:26:41 0.94379306 secs
           duration future_label                          future_uuid
1 1.714516e-02 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
6 2.143002e-02 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
2 4.189014e-04 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
3 7.331371e-04 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
4 8.416176e-05 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
5 2.978086e-03 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
9 8.734622e-01 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
7 4.780293e-04 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
8 1.364946e-03 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
                          session_uuid
1 b3f35fde-95a8-ec2c-f929-14c472832f82
6 b3f35fde-95a8-ec2c-f929-14c472832f82
2 b3f35fde-95a8-ec2c-f929-14c472832f82
3 b3f35fde-95a8-ec2c-f929-14c472832f82
4 b3f35fde-95a8-ec2c-f929-14c472832f82
5 b3f35fde-95a8-ec2c-f929-14c472832f82
9 87e60173-f6f1-a6d7-5add-a88f4ea1b5e7
7 b3f35fde-95a8-ec2c-f929-14c472832f82
8 b3f35fde-95a8-ec2c-f929-14c472832f82

[[2]]
           event   category parent               start              at
1         create   overhead   <NA> 2024-07-29 17:26:40 0.00000000 secs
6         launch   overhead   <NA> 2024-07-29 17:26:40 0.03895617 secs
2      getWorker   overhead launch 2024-07-29 17:26:40 0.04828596 secs
3    eraseWorker   overhead launch 2024-07-29 17:26:40 0.04964113 secs
4 attachPackages   overhead launch 2024-07-29 17:26:40 0.20238018 secs
5  exportGlobals   overhead launch 2024-07-29 17:26:40 0.20368314 secs
9       evaluate evaluation   <NA> 2024-07-29 17:26:40 0.20779014 secs
7  receiveResult   overhead gather 2024-07-29 17:26:41 1.32707810 secs
8         gather   overhead   <NA> 2024-07-29 17:26:41 1.32929707 secs
           duration future_label                          future_uuid
1 7.965088e-03 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
6 1.689069e-01 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
2 2.470016e-04 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
3 1.511629e-01 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
4 9.179115e-05 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
5 2.689838e-03 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
9 1.113383e+00 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
7 4.909039e-04 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
8 6.089211e-04 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
                          session_uuid
1 b3f35fde-95a8-ec2c-f929-14c472832f82
6 b3f35fde-95a8-ec2c-f929-14c472832f82
2 b3f35fde-95a8-ec2c-f929-14c472832f82
3 b3f35fde-95a8-ec2c-f929-14c472832f82
4 b3f35fde-95a8-ec2c-f929-14c472832f82
5 b3f35fde-95a8-ec2c-f929-14c472832f82
9 e2b6fff0-6e55-41f6-edbb-253dbb711725
7 b3f35fde-95a8-ec2c-f929-14c472832f82
8 b3f35fde-95a8-ec2c-f929-14c472832f82

[[3]]
           event   category parent               start              at
1         create   overhead   <NA> 2024-07-29 17:26:40 0.00000000 secs
6         launch   overhead   <NA> 2024-07-29 17:26:40 0.02554607 secs
2      getWorker   overhead launch 2024-07-29 17:26:40 0.03387403 secs
3    eraseWorker   overhead launch 2024-07-29 17:26:41 0.67485309 secs
4 attachPackages   overhead launch 2024-07-29 17:26:41 0.67657709 secs
5  exportGlobals   overhead launch 2024-07-29 17:26:41 0.67773914 secs
9       evaluate evaluation   <NA> 2024-07-29 17:26:41 0.68244600 secs
7  receiveResult   overhead gather 2024-07-29 17:26:42 2.25136805 secs
8         gather   overhead   <NA> 2024-07-29 17:26:42 2.25313115 secs
           duration future_label                          future_uuid
1 0.0046610832 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
6 0.6570119858 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
2 0.6397991180 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
3 0.0006198883 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
4 0.0000770092 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
5 0.0028419495 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
9 1.5679199696 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
7 0.0003919601 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
8 0.0005350113 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
                          session_uuid
1 b3f35fde-95a8-ec2c-f929-14c472832f82
6 b3f35fde-95a8-ec2c-f929-14c472832f82
2 b3f35fde-95a8-ec2c-f929-14c472832f82
3 b3f35fde-95a8-ec2c-f929-14c472832f82
4 b3f35fde-95a8-ec2c-f929-14c472832f82
5 b3f35fde-95a8-ec2c-f929-14c472832f82
9 87e60173-f6f1-a6d7-5add-a88f4ea1b5e7
7 b3f35fde-95a8-ec2c-f929-14c472832f82
8 b3f35fde-95a8-ec2c-f929-14c472832f82

> stopifnot(
+   is.list(js),
+   all(vapply(js, FUN = is.data.frame, FUN.VALUE = NA))
+ )
>   
> ## Shut down parallel workers
> plan(sequential)
[17:26:42.667] plan(): Setting new future strategy stack:
[17:26:42.667] List of future strategies:
[17:26:42.667] 1. sequential:
[17:26:42.667]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:42.667]    - tweaked: FALSE
[17:26:42.667]    - call: plan(sequential)
[17:26:42.675] 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-07-29 17:26:40 0.00000000 secs
6          launch   overhead   <NA> 2024-07-29 17:26:40 0.04578614 secs
2       getWorker   overhead launch 2024-07-29 17:26:40 0.05563402 secs
3     eraseWorker   overhead launch 2024-07-29 17:26:40 0.05833793 secs
4  attachPackages   overhead launch 2024-07-29 17:26:40 0.06034493 secs
5   exportGlobals   overhead launch 2024-07-29 17:26:40 0.06165600 secs
9        evaluate evaluation   <NA> 2024-07-29 17:26:40 0.06697392 secs
7   receiveResult   overhead gather 2024-07-29 17:26:41 0.94151592 secs
8          gather   overhead   <NA> 2024-07-29 17:26:41 0.94379306 secs
11         create   overhead   <NA> 2024-07-29 17:26:40 0.00000000 secs
61         launch   overhead   <NA> 2024-07-29 17:26:40 0.03895617 secs
21      getWorker   overhead launch 2024-07-29 17:26:40 0.04828596 secs
31    eraseWorker   overhead launch 2024-07-29 17:26:40 0.04964113 secs
41 attachPackages   overhead launch 2024-07-29 17:26:40 0.20238018 secs
51  exportGlobals   overhead launch 2024-07-29 17:26:40 0.20368314 secs
91       evaluate evaluation   <NA> 2024-07-29 17:26:40 0.20779014 secs
71  receiveResult   overhead gather 2024-07-29 17:26:41 1.32707810 secs
81         gather   overhead   <NA> 2024-07-29 17:26:41 1.32929707 secs
12         create   overhead   <NA> 2024-07-29 17:26:40 0.00000000 secs
62         launch   overhead   <NA> 2024-07-29 17:26:40 0.02554607 secs
22      getWorker   overhead launch 2024-07-29 17:26:40 0.03387403 secs
32    eraseWorker   overhead launch 2024-07-29 17:26:41 0.67485309 secs
42 attachPackages   overhead launch 2024-07-29 17:26:41 0.67657709 secs
52  exportGlobals   overhead launch 2024-07-29 17:26:41 0.67773914 secs
92       evaluate evaluation   <NA> 2024-07-29 17:26:41 0.68244600 secs
72  receiveResult   overhead gather 2024-07-29 17:26:42 2.25136805 secs
82         gather   overhead   <NA> 2024-07-29 17:26:42 2.25313115 secs
            duration future_label                          future_uuid
1  1.714516e-02 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
6  2.143002e-02 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
2  4.189014e-04 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
3  7.331371e-04 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
4  8.416176e-05 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
5  2.978086e-03 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
9  8.734622e-01 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
7  4.780293e-04 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
8  1.364946e-03 secs         <NA> 84700d6c-e8be-f732-4c1c-579fc068f944
11 7.965088e-03 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
61 1.689069e-01 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
21 2.470016e-04 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
31 1.511629e-01 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
41 9.179115e-05 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
51 2.689838e-03 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
91 1.113383e+00 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
71 4.909039e-04 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
81 6.089211e-04 secs         <NA> 0ae8a236-4b47-2735-3c57-8d7e949779a2
12 4.661083e-03 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
62 6.570120e-01 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
22 6.397991e-01 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
32 6.198883e-04 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
42 7.700920e-05 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
52 2.841949e-03 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
92 1.567920e+00 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
72 3.919601e-04 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
82 5.350113e-04 secs         <NA> 32fa31a2-fd06-435c-59ad-259e47b637ea
                           session_uuid
1  b3f35fde-95a8-ec2c-f929-14c472832f82
6  b3f35fde-95a8-ec2c-f929-14c472832f82
2  b3f35fde-95a8-ec2c-f929-14c472832f82
3  b3f35fde-95a8-ec2c-f929-14c472832f82
4  b3f35fde-95a8-ec2c-f929-14c472832f82
5  b3f35fde-95a8-ec2c-f929-14c472832f82
9  87e60173-f6f1-a6d7-5add-a88f4ea1b5e7
7  b3f35fde-95a8-ec2c-f929-14c472832f82
8  b3f35fde-95a8-ec2c-f929-14c472832f82
11 b3f35fde-95a8-ec2c-f929-14c472832f82
61 b3f35fde-95a8-ec2c-f929-14c472832f82
21 b3f35fde-95a8-ec2c-f929-14c472832f82
31 b3f35fde-95a8-ec2c-f929-14c472832f82
41 b3f35fde-95a8-ec2c-f929-14c472832f82
51 b3f35fde-95a8-ec2c-f929-14c472832f82
91 e2b6fff0-6e55-41f6-edbb-253dbb711725
71 b3f35fde-95a8-ec2c-f929-14c472832f82
81 b3f35fde-95a8-ec2c-f929-14c472832f82
12 b3f35fde-95a8-ec2c-f929-14c472832f82
62 b3f35fde-95a8-ec2c-f929-14c472832f82
22 b3f35fde-95a8-ec2c-f929-14c472832f82
32 b3f35fde-95a8-ec2c-f929-14c472832f82
42 b3f35fde-95a8-ec2c-f929-14c472832f82
52 b3f35fde-95a8-ec2c-f929-14c472832f82
92 87e60173-f6f1-a6d7-5add-a88f4ea1b5e7
72 b3f35fde-95a8-ec2c-f929-14c472832f82
82 b3f35fde-95a8-ec2c-f929-14c472832f82
> 
> stats <- summary(js)
> print(stats)
Number of futures: 3
  summary       evaluate evaluate_ratio        overhead overhead_ratio
1     min 0.8734622 secs      0.9241441 0.03994012 secs     0.04225761
2    mean 1.1849217 secs      0.7849364 0.29320971 secs     0.19423306
3  median 1.1133828 secs      0.8371891 0.17748094 secs     0.13345375
4     max 1.5679200 secs      0.6957197 0.66220808 secs     0.29383592
5   total 3.5547650 secs      0.7849364 0.87962914 secs     0.19423306
       duration      walltime
1 0.945158 secs 0.945158 secs
2 1.509577 secs 1.509577 secs
3 1.329906 secs 1.329906 secs
4 2.253666 secs 2.253666 secs
5 4.528730 secs 4.528730 secs
> 
> message("*** summary() of FutureJournal ... done")
*** summary() of FutureJournal ... done
> 
> #source("incl/end.R")
> 
> proc.time()
   user  system elapsed 
   0.71    0.18    4.15