Last updated on 2023-05-29 18:02:08 CEST.
| Flavor | Version | Tinstall | Tcheck | Ttotal | Status | Flags |
|---|---|---|---|---|---|---|
| r-devel-linux-x86_64-debian-clang | 1.11.0 | 3.46 | 244.54 | 248.00 | OK | |
| r-devel-linux-x86_64-debian-gcc | 1.11.0 | 3.52 | 200.95 | 204.47 | ERROR | |
| r-devel-linux-x86_64-fedora-clang | 1.11.0 | 336.63 | OK | |||
| r-devel-linux-x86_64-fedora-gcc | 1.11.0 | 357.57 | OK | |||
| r-devel-windows-x86_64 | 1.11.0 | 5.00 | 191.00 | 196.00 | OK | |
| r-patched-linux-x86_64 | 1.11.0 | 4.64 | 248.37 | 253.01 | OK | |
| r-release-linux-x86_64 | 1.11.0 | 3.86 | 251.55 | 255.41 | OK | |
| r-release-macos-arm64 | 1.11.0 | 125.00 | OK | |||
| r-release-macos-x86_64 | 1.10.0 | 189.00 | OK | |||
| r-release-windows-x86_64 | 1.11.0 | 5.00 | 231.00 | 236.00 | OK | |
| r-oldrel-macos-arm64 | 1.11.0 | 131.00 | OK | |||
| r-oldrel-macos-x86_64 | 1.11.0 | 174.00 | OK | |||
| r-oldrel-windows-x86_64 | 1.11.0 | 6.00 | 217.00 | 223.00 | OK |
Version: 1.11.0
Check: tests
Result: ERROR
Running ‘fold.R’ [6s/9s]
Running ‘future_apply.R’ [8s/18s]
Running ‘future_by.R’ [7s/16s]
Running ‘future_eapply.R’ [3s/9s]
Running ‘future_lapply,RNG.R’ [33s/101s]
Running ‘future_lapply,globals.R’ [6s/18s]
Running ‘future_lapply.R’ [28s/60s]
Running ‘future_mapply,globals.R’ [3s/11s]
Running ‘future_mapply.R’ [13s/30s]
Running ‘future_replicate.R’ [4s/11s]
Running ‘future_sapply.R’ [39s/81s]
Running ‘future_tapply.R’ [1s/2s]
Running ‘future_vapply.R’ [12s/29s]
Running ‘globals,tricky_recursive.R’ [2s/6s]
Running ‘rng.R’ [1s/1s]
Running ‘stdout.R’ [4s/20s]
Running ‘utils.R’ [1s/1s]
Running the tests in ‘tests/stdout.R’ failed.
Complete output:
> source("incl/start.R")
Loading required package: future
[21:39:00.816] plan(): Setting new future strategy stack:
[21:39:00.817] List of future strategies:
[21:39:00.817] 1. sequential:
[21:39:00.817] - args: function (..., envir = parent.frame())
[21:39:00.817] - tweaked: FALSE
[21:39:00.817] - call: future::plan("sequential")
[21:39:00.856] plan(): nbrOfWorkers() = 1
>
> message("*** future_*apply() and 'future.stdout' ...")
*** future_*apply() and 'future.stdout' ...
>
> options(future.debug = TRUE)
>
> truth <- list()
>
> out <- utils::capture.output({
+ y <- lapply(1:0, FUN = function(x) {
+ print(x)
+ })
+ })
> truth[["lapply"]] <- list(value = y, stdout = out)
>
> out <- utils::capture.output({
+ y <- mapply(1:0, 0:1, FUN = function(x, y) {
+ print(list(x = x, y = y))
+ })
+ })
> truth[["mapply"]] <- list(value = y, stdout = out)
>
> for (cores in 1:availCores) {
+ message(sprintf(" - Testing with %d cores ...", cores))
+ options(mc.cores = cores)
+
+ for (strategy in supportedStrategies(cores)) {
+ message(sprintf("* plan('%s') ...", strategy))
+ plan(strategy)
+
+ for (fun in names(truth)) {
+ for (stdout in c(FALSE, TRUE, NA)) {
+ message(sprintf("* future_%s(x, ..., future.stdout = %s) ...", fun, stdout))
+
+ out <- utils::capture.output({
+ if (fun == "lapply") {
+ y <- future_lapply(1:0, FUN = function(x) {
+ Sys.sleep(x / 2) ## make futures resolve out of order
+ print(x)
+ }, future.stdout = stdout)
+ } else if (fun == "mapply") {
+ y <- future_mapply(1:0, 0:1, FUN = function(x, y) {
+ Sys.sleep(x / 2) ## make futures resolve out of order
+ print(list(x = x, y = y))
+ }, future.stdout = stdout)
+ }
+ })
+ stopifnot(identical(y, truth[[fun]]$value))
+
+ if (isTRUE(stdout)) {
+ stopifnot(identical(out, truth[[fun]]$stdout))
+ } else if (is.na(stdout)) {
+ } else {
+ stopifnot(nchar(out) == 0)
+ }
+
+ message(sprintf("* future_%s(x, ..., future.stdout = %s) ... DONE", fun, stdout))
+ } ## for (stdout ...)
+ } ## for (fun ...)
+
+ message(sprintf("* plan('%s') ... DONE", strategy))
+ }
+
+ message(sprintf(" - Testing with %d cores ... DONE", cores))
+ }
- Testing with 1 cores ...
* plan('sequential') ...
[21:39:01.056] plan(): Setting new future strategy stack:
[21:39:01.056] List of future strategies:
[21:39:01.056] 1. sequential:
[21:39:01.056] - args: function (..., envir = parent.frame())
[21:39:01.056] - tweaked: FALSE
[21:39:01.056] - call: plan(strategy)
[21:39:01.116] plan(): nbrOfWorkers() = 1
* future_lapply(x, ..., future.stdout = FALSE) ...
[21:39:01.117] future_lapply() ...
[21:39:01.129] Number of chunks: 1
[21:39:01.130] getGlobalsAndPackagesXApply() ...
[21:39:01.130] - future.globals: TRUE
[21:39:01.148] getGlobalsAndPackages() ...
[21:39:01.148] Searching for globals...
[21:39:01.153] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[21:39:01.154] Searching for globals ... DONE
[21:39:01.154] Resolving globals: FALSE
[21:39:01.156] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[21:39:01.157] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[21:39:01.158] - globals: [1] 'FUN'
[21:39:01.158]
[21:39:01.158] getGlobalsAndPackages() ... DONE
[21:39:01.158] - globals found/used: [n=1] 'FUN'
[21:39:01.159] - needed namespaces: [n=0]
[21:39:01.159] Finding globals ... DONE
[21:39:01.159] - use_args: TRUE
[21:39:01.159] - Getting '...' globals ...
[21:39:01.161] resolve() on list ...
[21:39:01.161] recursive: 0
[21:39:01.162] length: 1
[21:39:01.162] elements: '...'
[21:39:01.179] length: 0 (resolved future 1)
[21:39:01.179] resolve() on list ... DONE
[21:39:01.179] - '...' content: [n=0]
[21:39:01.180] List of 1
[21:39:01.180] $ ...: list()
[21:39:01.180] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:01.180] - attr(*, "where")=List of 1
[21:39:01.180] ..$ ...:<environment: 0x55c1f0a2c638>
[21:39:01.180] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:01.180] - attr(*, "resolved")= logi TRUE
[21:39:01.180] - attr(*, "total_size")= num NA
[21:39:01.190] - Getting '...' globals ... DONE
[21:39:01.191] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[21:39:01.191] List of 2
[21:39:01.191] $ ...future.FUN:function (x)
[21:39:01.191] $ ... : list()
[21:39:01.191] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:01.191] - attr(*, "where")=List of 2
[21:39:01.191] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:01.191] ..$ ... :<environment: 0x55c1f0a2c638>
[21:39:01.191] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:01.191] - attr(*, "resolved")= logi FALSE
[21:39:01.191] - attr(*, "total_size")= num 4720
[21:39:01.213] Packages to be attached in all futures: [n=0]
[21:39:01.213] getGlobalsAndPackagesXApply() ... DONE
[21:39:01.214] Number of futures (= number of chunks): 1
[21:39:01.214] Launching 1 futures (chunks) ...
[21:39:01.215] Chunk #1 of 1 ...
[21:39:01.215] - Finding globals in 'X' for chunk #1 ...
[21:39:01.215] getGlobalsAndPackages() ...
[21:39:01.216] Searching for globals...
[21:39:01.216]
[21:39:01.216] Searching for globals ... DONE
[21:39:01.217] - globals: [0] <none>
[21:39:01.217] getGlobalsAndPackages() ... DONE
[21:39:01.217] + additional globals found: [n=0]
[21:39:01.217] + additional namespaces needed: [n=0]
[21:39:01.217] - Finding globals in 'X' for chunk #1 ... DONE
[21:39:01.218] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:01.218] - seeds: <none>
[21:39:01.219] getGlobalsAndPackages() ...
[21:39:01.219] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:01.219] Resolving globals: FALSE
[21:39:01.219] Tweak future expression to call with '...' arguments ...
[21:39:01.220] {
[21:39:01.220] do.call(function(...) {
[21:39:01.220] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:01.220] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:01.220] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:01.220] on.exit(options(oopts), add = TRUE)
[21:39:01.220] }
[21:39:01.220] {
[21:39:01.220] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:01.220] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:01.220] ...future.FUN(...future.X_jj, ...)
[21:39:01.220] })
[21:39:01.220] }
[21:39:01.220] }, args = future.call.arguments)
[21:39:01.220] }
[21:39:01.220] Tweak future expression to call with '...' arguments ... DONE
[21:39:01.221] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:01.221]
[21:39:01.221] getGlobalsAndPackages() ... DONE
[21:39:01.223] run() for 'Future' ...
[21:39:01.223] - state: 'created'
[21:39:01.224] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[21:39:01.224] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:01.225] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:01.225] - Field: 'label'
[21:39:01.225] - Field: 'local'
[21:39:01.225] - Field: 'owner'
[21:39:01.225] - Field: 'envir'
[21:39:01.226] - Field: 'packages'
[21:39:01.226] - Field: 'gc'
[21:39:01.226] - Field: 'conditions'
[21:39:01.226] - Field: 'expr'
[21:39:01.243] - Field: 'uuid'
[21:39:01.243] - Field: 'seed'
[21:39:01.243] - Field: 'version'
[21:39:01.243] - Field: 'result'
[21:39:01.244] - Field: 'asynchronous'
[21:39:01.244] - Field: 'calls'
[21:39:01.244] - Field: 'globals'
[21:39:01.244] - Field: 'stdout'
[21:39:01.245] - Field: 'earlySignal'
[21:39:01.245] - Field: 'lazy'
[21:39:01.245] - Field: 'state'
[21:39:01.245] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:01.245] - Launch lazy future ...
[21:39:01.247] Packages needed by the future expression (n = 0): <none>
[21:39:01.247] Packages needed by future strategies (n = 0): <none>
[21:39:01.249] {
[21:39:01.249] {
[21:39:01.249] {
[21:39:01.249] ...future.startTime <- base::Sys.time()
[21:39:01.249] {
[21:39:01.249] {
[21:39:01.249] {
[21:39:01.249] base::local({
[21:39:01.249] has_future <- base::requireNamespace("future",
[21:39:01.249] quietly = TRUE)
[21:39:01.249] if (has_future) {
[21:39:01.249] ns <- base::getNamespace("future")
[21:39:01.249] version <- ns[[".package"]][["version"]]
[21:39:01.249] if (is.null(version))
[21:39:01.249] version <- utils::packageVersion("future")
[21:39:01.249] }
[21:39:01.249] else {
[21:39:01.249] version <- NULL
[21:39:01.249] }
[21:39:01.249] if (!has_future || version < "1.8.0") {
[21:39:01.249] info <- base::c(r_version = base::gsub("R version ",
[21:39:01.249] "", base::R.version$version.string),
[21:39:01.249] platform = base::sprintf("%s (%s-bit)",
[21:39:01.249] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:01.249] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:01.249] "release", "version")], collapse = " "),
[21:39:01.249] hostname = base::Sys.info()[["nodename"]])
[21:39:01.249] info <- base::sprintf("%s: %s", base::names(info),
[21:39:01.249] info)
[21:39:01.249] info <- base::paste(info, collapse = "; ")
[21:39:01.249] if (!has_future) {
[21:39:01.249] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:01.249] info)
[21:39:01.249] }
[21:39:01.249] else {
[21:39:01.249] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:01.249] info, version)
[21:39:01.249] }
[21:39:01.249] base::stop(msg)
[21:39:01.249] }
[21:39:01.249] })
[21:39:01.249] }
[21:39:01.249] options(future.plan = NULL)
[21:39:01.249] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:01.249] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:01.249] }
[21:39:01.249] ...future.workdir <- getwd()
[21:39:01.249] }
[21:39:01.249] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:01.249] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:01.249] }
[21:39:01.249] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:01.249] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:01.249] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:01.249] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:01.249] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:01.249] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:01.249] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:01.249] base::names(...future.oldOptions))
[21:39:01.249] }
[21:39:01.249] if (FALSE) {
[21:39:01.249] }
[21:39:01.249] else {
[21:39:01.249] if (FALSE) {
[21:39:01.249] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:01.249] open = "w")
[21:39:01.249] }
[21:39:01.249] else {
[21:39:01.249] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:01.249] windows = "NUL", "/dev/null"), open = "w")
[21:39:01.249] }
[21:39:01.249] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:01.249] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:01.249] base::sink(type = "output", split = FALSE)
[21:39:01.249] base::close(...future.stdout)
[21:39:01.249] }, add = TRUE)
[21:39:01.249] }
[21:39:01.249] ...future.frame <- base::sys.nframe()
[21:39:01.249] ...future.conditions <- base::list()
[21:39:01.249] ...future.rng <- base::globalenv()$.Random.seed
[21:39:01.249] if (FALSE) {
[21:39:01.249] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:01.249] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:01.249] }
[21:39:01.249] ...future.result <- base::tryCatch({
[21:39:01.249] base::withCallingHandlers({
[21:39:01.249] ...future.value <- base::withVisible(base::local({
[21:39:01.249] do.call(function(...) {
[21:39:01.249] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:01.249] if (!identical(...future.globals.maxSize.org,
[21:39:01.249] ...future.globals.maxSize)) {
[21:39:01.249] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:01.249] on.exit(options(oopts), add = TRUE)
[21:39:01.249] }
[21:39:01.249] {
[21:39:01.249] lapply(seq_along(...future.elements_ii),
[21:39:01.249] FUN = function(jj) {
[21:39:01.249] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:01.249] ...future.FUN(...future.X_jj, ...)
[21:39:01.249] })
[21:39:01.249] }
[21:39:01.249] }, args = future.call.arguments)
[21:39:01.249] }))
[21:39:01.249] future::FutureResult(value = ...future.value$value,
[21:39:01.249] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:01.249] ...future.rng), globalenv = if (FALSE)
[21:39:01.249] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:01.249] ...future.globalenv.names))
[21:39:01.249] else NULL, started = ...future.startTime, version = "1.8")
[21:39:01.249] }, condition = base::local({
[21:39:01.249] c <- base::c
[21:39:01.249] inherits <- base::inherits
[21:39:01.249] invokeRestart <- base::invokeRestart
[21:39:01.249] length <- base::length
[21:39:01.249] list <- base::list
[21:39:01.249] seq.int <- base::seq.int
[21:39:01.249] signalCondition <- base::signalCondition
[21:39:01.249] sys.calls <- base::sys.calls
[21:39:01.249] `[[` <- base::`[[`
[21:39:01.249] `+` <- base::`+`
[21:39:01.249] `<<-` <- base::`<<-`
[21:39:01.249] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:01.249] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:01.249] 3L)]
[21:39:01.249] }
[21:39:01.249] function(cond) {
[21:39:01.249] is_error <- inherits(cond, "error")
[21:39:01.249] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:01.249] NULL)
[21:39:01.249] if (is_error) {
[21:39:01.249] sessionInformation <- function() {
[21:39:01.249] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:01.249] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:01.249] search = base::search(), system = base::Sys.info())
[21:39:01.249] }
[21:39:01.249] ...future.conditions[[length(...future.conditions) +
[21:39:01.249] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:01.249] cond$call), session = sessionInformation(),
[21:39:01.249] timestamp = base::Sys.time(), signaled = 0L)
[21:39:01.249] signalCondition(cond)
[21:39:01.249] }
[21:39:01.249] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:01.249] "immediateCondition"))) {
[21:39:01.249] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:01.249] ...future.conditions[[length(...future.conditions) +
[21:39:01.249] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:01.249] if (TRUE && !signal) {
[21:39:01.249] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:01.249] {
[21:39:01.249] inherits <- base::inherits
[21:39:01.249] invokeRestart <- base::invokeRestart
[21:39:01.249] is.null <- base::is.null
[21:39:01.249] muffled <- FALSE
[21:39:01.249] if (inherits(cond, "message")) {
[21:39:01.249] muffled <- grepl(pattern, "muffleMessage")
[21:39:01.249] if (muffled)
[21:39:01.249] invokeRestart("muffleMessage")
[21:39:01.249] }
[21:39:01.249] else if (inherits(cond, "warning")) {
[21:39:01.249] muffled <- grepl(pattern, "muffleWarning")
[21:39:01.249] if (muffled)
[21:39:01.249] invokeRestart("muffleWarning")
[21:39:01.249] }
[21:39:01.249] else if (inherits(cond, "condition")) {
[21:39:01.249] if (!is.null(pattern)) {
[21:39:01.249] computeRestarts <- base::computeRestarts
[21:39:01.249] grepl <- base::grepl
[21:39:01.249] restarts <- computeRestarts(cond)
[21:39:01.249] for (restart in restarts) {
[21:39:01.249] name <- restart$name
[21:39:01.249] if (is.null(name))
[21:39:01.249] next
[21:39:01.249] if (!grepl(pattern, name))
[21:39:01.249] next
[21:39:01.249] invokeRestart(restart)
[21:39:01.249] muffled <- TRUE
[21:39:01.249] break
[21:39:01.249] }
[21:39:01.249] }
[21:39:01.249] }
[21:39:01.249] invisible(muffled)
[21:39:01.249] }
[21:39:01.249] muffleCondition(cond, pattern = "^muffle")
[21:39:01.249] }
[21:39:01.249] }
[21:39:01.249] else {
[21:39:01.249] if (TRUE) {
[21:39:01.249] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:01.249] {
[21:39:01.249] inherits <- base::inherits
[21:39:01.249] invokeRestart <- base::invokeRestart
[21:39:01.249] is.null <- base::is.null
[21:39:01.249] muffled <- FALSE
[21:39:01.249] if (inherits(cond, "message")) {
[21:39:01.249] muffled <- grepl(pattern, "muffleMessage")
[21:39:01.249] if (muffled)
[21:39:01.249] invokeRestart("muffleMessage")
[21:39:01.249] }
[21:39:01.249] else if (inherits(cond, "warning")) {
[21:39:01.249] muffled <- grepl(pattern, "muffleWarning")
[21:39:01.249] if (muffled)
[21:39:01.249] invokeRestart("muffleWarning")
[21:39:01.249] }
[21:39:01.249] else if (inherits(cond, "condition")) {
[21:39:01.249] if (!is.null(pattern)) {
[21:39:01.249] computeRestarts <- base::computeRestarts
[21:39:01.249] grepl <- base::grepl
[21:39:01.249] restarts <- computeRestarts(cond)
[21:39:01.249] for (restart in restarts) {
[21:39:01.249] name <- restart$name
[21:39:01.249] if (is.null(name))
[21:39:01.249] next
[21:39:01.249] if (!grepl(pattern, name))
[21:39:01.249] next
[21:39:01.249] invokeRestart(restart)
[21:39:01.249] muffled <- TRUE
[21:39:01.249] break
[21:39:01.249] }
[21:39:01.249] }
[21:39:01.249] }
[21:39:01.249] invisible(muffled)
[21:39:01.249] }
[21:39:01.249] muffleCondition(cond, pattern = "^muffle")
[21:39:01.249] }
[21:39:01.249] }
[21:39:01.249] }
[21:39:01.249] }))
[21:39:01.249] }, error = function(ex) {
[21:39:01.249] base::structure(base::list(value = NULL, visible = NULL,
[21:39:01.249] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:01.249] ...future.rng), started = ...future.startTime,
[21:39:01.249] finished = Sys.time(), session_uuid = NA_character_,
[21:39:01.249] version = "1.8"), class = "FutureResult")
[21:39:01.249] }, finally = {
[21:39:01.249] if (!identical(...future.workdir, getwd()))
[21:39:01.249] setwd(...future.workdir)
[21:39:01.249] {
[21:39:01.249] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:01.249] ...future.oldOptions$nwarnings <- NULL
[21:39:01.249] }
[21:39:01.249] base::options(...future.oldOptions)
[21:39:01.249] if (.Platform$OS.type == "windows") {
[21:39:01.249] old_names <- names(...future.oldEnvVars)
[21:39:01.249] envs <- base::Sys.getenv()
[21:39:01.249] names <- names(envs)
[21:39:01.249] common <- intersect(names, old_names)
[21:39:01.249] added <- setdiff(names, old_names)
[21:39:01.249] removed <- setdiff(old_names, names)
[21:39:01.249] changed <- common[...future.oldEnvVars[common] !=
[21:39:01.249] envs[common]]
[21:39:01.249] NAMES <- toupper(changed)
[21:39:01.249] args <- list()
[21:39:01.249] for (kk in seq_along(NAMES)) {
[21:39:01.249] name <- changed[[kk]]
[21:39:01.249] NAME <- NAMES[[kk]]
[21:39:01.249] if (name != NAME && is.element(NAME, old_names))
[21:39:01.249] next
[21:39:01.249] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:01.249] }
[21:39:01.249] NAMES <- toupper(added)
[21:39:01.249] for (kk in seq_along(NAMES)) {
[21:39:01.249] name <- added[[kk]]
[21:39:01.249] NAME <- NAMES[[kk]]
[21:39:01.249] if (name != NAME && is.element(NAME, old_names))
[21:39:01.249] next
[21:39:01.249] args[[name]] <- ""
[21:39:01.249] }
[21:39:01.249] NAMES <- toupper(removed)
[21:39:01.249] for (kk in seq_along(NAMES)) {
[21:39:01.249] name <- removed[[kk]]
[21:39:01.249] NAME <- NAMES[[kk]]
[21:39:01.249] if (name != NAME && is.element(NAME, old_names))
[21:39:01.249] next
[21:39:01.249] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:01.249] }
[21:39:01.249] if (length(args) > 0)
[21:39:01.249] base::do.call(base::Sys.setenv, args = args)
[21:39:01.249] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:01.249] }
[21:39:01.249] else {
[21:39:01.249] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:01.249] }
[21:39:01.249] {
[21:39:01.249] if (base::length(...future.futureOptionsAdded) >
[21:39:01.249] 0L) {
[21:39:01.249] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:01.249] base::names(opts) <- ...future.futureOptionsAdded
[21:39:01.249] base::options(opts)
[21:39:01.249] }
[21:39:01.249] {
[21:39:01.249] {
[21:39:01.249] NULL
[21:39:01.249] RNGkind("Mersenne-Twister")
[21:39:01.249] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:01.249] inherits = FALSE)
[21:39:01.249] }
[21:39:01.249] options(future.plan = NULL)
[21:39:01.249] if (is.na(NA_character_))
[21:39:01.249] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:01.249] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:01.249] future::plan(list(function (..., envir = parent.frame())
[21:39:01.249] {
[21:39:01.249] future <- SequentialFuture(..., envir = envir)
[21:39:01.249] if (!future$lazy)
[21:39:01.249] future <- run(future)
[21:39:01.249] invisible(future)
[21:39:01.249] }), .cleanup = FALSE, .init = FALSE)
[21:39:01.249] }
[21:39:01.249] }
[21:39:01.249] }
[21:39:01.249] })
[21:39:01.249] if (TRUE) {
[21:39:01.249] base::sink(type = "output", split = FALSE)
[21:39:01.249] if (FALSE) {
[21:39:01.249] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:01.249] }
[21:39:01.249] else {
[21:39:01.249] ...future.result["stdout"] <- base::list(NULL)
[21:39:01.249] }
[21:39:01.249] base::close(...future.stdout)
[21:39:01.249] ...future.stdout <- NULL
[21:39:01.249] }
[21:39:01.249] ...future.result$conditions <- ...future.conditions
[21:39:01.249] ...future.result$finished <- base::Sys.time()
[21:39:01.249] ...future.result
[21:39:01.249] }
[21:39:01.253] assign_globals() ...
[21:39:01.254] List of 5
[21:39:01.254] $ ...future.FUN :function (x)
[21:39:01.254] $ future.call.arguments : list()
[21:39:01.254] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:01.254] $ ...future.elements_ii :List of 2
[21:39:01.254] ..$ : int 1
[21:39:01.254] ..$ : int 0
[21:39:01.254] $ ...future.seeds_ii : NULL
[21:39:01.254] $ ...future.globals.maxSize: NULL
[21:39:01.254] - attr(*, "resolved")= logi FALSE
[21:39:01.254] - attr(*, "total_size")= num 4720
[21:39:01.254] - attr(*, "where")=List of 5
[21:39:01.254] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:01.254] ..$ future.call.arguments :<environment: R_EmptyEnv>
[21:39:01.254] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:01.254] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:01.254] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:01.254] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:01.254] - attr(*, "already-done")= logi TRUE
[21:39:01.287] - reassign environment for '...future.FUN'
[21:39:01.287] - copied '...future.FUN' to environment
[21:39:01.287] - copied 'future.call.arguments' to environment
[21:39:01.288] - copied '...future.elements_ii' to environment
[21:39:01.288] - copied '...future.seeds_ii' to environment
[21:39:01.288] - copied '...future.globals.maxSize' to environment
[21:39:01.288] assign_globals() ... done
[21:39:01.289] plan(): Setting new future strategy stack:
[21:39:01.289] List of future strategies:
[21:39:01.289] 1. sequential:
[21:39:01.289] - args: function (..., envir = parent.frame())
[21:39:01.289] - tweaked: FALSE
[21:39:01.289] - call: NULL
[21:39:01.290] plan(): nbrOfWorkers() = 1
[21:39:01.809] plan(): Setting new future strategy stack:
[21:39:01.810] List of future strategies:
[21:39:01.810] 1. sequential:
[21:39:01.810] - args: function (..., envir = parent.frame())
[21:39:01.810] - tweaked: FALSE
[21:39:01.810] - call: plan(strategy)
[21:39:01.811] plan(): nbrOfWorkers() = 1
[21:39:01.811] SequentialFuture started (and completed)
[21:39:01.812] - Launch lazy future ... done
[21:39:01.812] run() for 'SequentialFuture' ... done
[21:39:01.813] Created future:
[21:39:01.813] SequentialFuture:
[21:39:01.813] Label: 'future_lapply-1'
[21:39:01.813] Expression:
[21:39:01.813] {
[21:39:01.813] do.call(function(...) {
[21:39:01.813] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:01.813] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:01.813] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:01.813] on.exit(options(oopts), add = TRUE)
[21:39:01.813] }
[21:39:01.813] {
[21:39:01.813] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:01.813] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:01.813] ...future.FUN(...future.X_jj, ...)
[21:39:01.813] })
[21:39:01.813] }
[21:39:01.813] }, args = future.call.arguments)
[21:39:01.813] }
[21:39:01.813] Lazy evaluation: FALSE
[21:39:01.813] Asynchronous evaluation: FALSE
[21:39:01.813] Local evaluation: TRUE
[21:39:01.813] Environment: R_GlobalEnv
[21:39:01.813] Capture standard output: FALSE
[21:39:01.813] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:01.813] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:01.813] Packages: <none>
[21:39:01.813] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:01.813] Resolved: TRUE
[21:39:01.813] Value: 112 bytes of class 'list'
[21:39:01.813] Early signaling: FALSE
[21:39:01.813] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:01.813] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:01.816] Chunk #1 of 1 ... DONE
[21:39:01.817] Launching 1 futures (chunks) ... DONE
[21:39:01.817] Resolving 1 futures (chunks) ...
[21:39:01.817] resolve() on list ...
[21:39:01.817] recursive: 0
[21:39:01.818] length: 1
[21:39:01.818]
[21:39:01.818] resolved() for 'SequentialFuture' ...
[21:39:01.819] - state: 'finished'
[21:39:01.819] - run: TRUE
[21:39:01.819] - result: 'FutureResult'
[21:39:01.819] resolved() for 'SequentialFuture' ... done
[21:39:01.820] Future #1
[21:39:01.820] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:01.821] - nx: 1
[21:39:01.821] - relay: TRUE
[21:39:01.821] - stdout: TRUE
[21:39:01.821] - signal: TRUE
[21:39:01.822] - resignal: FALSE
[21:39:01.822] - force: TRUE
[21:39:01.822] - relayed: [n=1] FALSE
[21:39:01.822] - queued futures: [n=1] FALSE
[21:39:01.835] - until=1
[21:39:01.835] - relaying element #1
[21:39:01.835] - relayed: [n=1] TRUE
[21:39:01.836] - queued futures: [n=1] TRUE
[21:39:01.836] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:01.836] length: 0 (resolved future 1)
[21:39:01.837] Relaying remaining futures
[21:39:01.837] signalConditionsASAP(NULL, pos=0) ...
[21:39:01.837] - nx: 1
[21:39:01.837] - relay: TRUE
[21:39:01.837] - stdout: TRUE
[21:39:01.837] - signal: TRUE
[21:39:01.838] - resignal: FALSE
[21:39:01.838] - force: TRUE
[21:39:01.838] - relayed: [n=1] TRUE
[21:39:01.838] - queued futures: [n=1] TRUE
- flush all
[21:39:01.839] - relayed: [n=1] TRUE
[21:39:01.839] - queued futures: [n=1] TRUE
[21:39:01.839] signalConditionsASAP(NULL, pos=0) ... done
[21:39:01.839] resolve() on list ... DONE
[21:39:01.840] - Number of value chunks collected: 1
[21:39:01.840] Resolving 1 futures (chunks) ... DONE
[21:39:01.840] Reducing values from 1 chunks ...
[21:39:01.840] - Number of values collected after concatenation: 2
[21:39:01.841] - Number of values expected: 2
[21:39:01.841] Reducing values from 1 chunks ... DONE
[21:39:01.841] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = FALSE) ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ...
[21:39:01.842] future_lapply() ...
[21:39:01.844] Number of chunks: 1
[21:39:01.844] getGlobalsAndPackagesXApply() ...
[21:39:01.844] - future.globals: TRUE
[21:39:01.844] getGlobalsAndPackages() ...
[21:39:01.845] Searching for globals...
[21:39:01.848] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[21:39:01.848] Searching for globals ... DONE
[21:39:01.848] Resolving globals: FALSE
[21:39:01.849] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[21:39:01.850] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[21:39:01.850] - globals: [1] 'FUN'
[21:39:01.862]
[21:39:01.863] getGlobalsAndPackages() ... DONE
[21:39:01.863] - globals found/used: [n=1] 'FUN'
[21:39:01.863] - needed namespaces: [n=0]
[21:39:01.864] Finding globals ... DONE
[21:39:01.864] - use_args: TRUE
[21:39:01.864] - Getting '...' globals ...
[21:39:01.865] resolve() on list ...
[21:39:01.865] recursive: 0
[21:39:01.865] length: 1
[21:39:01.865] elements: '...'
[21:39:01.866] length: 0 (resolved future 1)
[21:39:01.866] resolve() on list ... DONE
[21:39:01.866] - '...' content: [n=0]
[21:39:01.867] List of 1
[21:39:01.867] $ ...: list()
[21:39:01.867] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:01.867] - attr(*, "where")=List of 1
[21:39:01.867] ..$ ...:<environment: 0x55c1f0192228>
[21:39:01.867] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:01.867] - attr(*, "resolved")= logi TRUE
[21:39:01.867] - attr(*, "total_size")= num NA
[21:39:01.873] - Getting '...' globals ... DONE
[21:39:01.874] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[21:39:01.874] List of 2
[21:39:01.874] $ ...future.FUN:function (x)
[21:39:01.874] $ ... : list()
[21:39:01.874] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:01.874] - attr(*, "where")=List of 2
[21:39:01.874] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:01.874] ..$ ... :<environment: 0x55c1f0192228>
[21:39:01.874] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:01.874] - attr(*, "resolved")= logi FALSE
[21:39:01.874] - attr(*, "total_size")= num 4720
[21:39:01.880] Packages to be attached in all futures: [n=0]
[21:39:01.881] getGlobalsAndPackagesXApply() ... DONE
[21:39:01.881] Number of futures (= number of chunks): 1
[21:39:01.881] Launching 1 futures (chunks) ...
[21:39:01.882] Chunk #1 of 1 ...
[21:39:01.901] - Finding globals in 'X' for chunk #1 ...
[21:39:01.902] getGlobalsAndPackages() ...
[21:39:01.902] Searching for globals...
[21:39:01.915]
[21:39:01.915] Searching for globals ... DONE
[21:39:01.915] - globals: [0] <none>
[21:39:01.915] getGlobalsAndPackages() ... DONE
[21:39:01.916] + additional globals found: [n=0]
[21:39:01.916] + additional namespaces needed: [n=0]
[21:39:01.916] - Finding globals in 'X' for chunk #1 ... DONE
[21:39:01.916] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:01.917] - seeds: <none>
[21:39:01.917] getGlobalsAndPackages() ...
[21:39:01.917] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:01.917] Resolving globals: FALSE
[21:39:01.918] Tweak future expression to call with '...' arguments ...
[21:39:01.918] {
[21:39:01.918] do.call(function(...) {
[21:39:01.918] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:01.918] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:01.918] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:01.918] on.exit(options(oopts), add = TRUE)
[21:39:01.918] }
[21:39:01.918] {
[21:39:01.918] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:01.918] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:01.918] ...future.FUN(...future.X_jj, ...)
[21:39:01.918] })
[21:39:01.918] }
[21:39:01.918] }, args = future.call.arguments)
[21:39:01.918] }
[21:39:01.919] Tweak future expression to call with '...' arguments ... DONE
[21:39:01.919] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:01.920]
[21:39:01.920] getGlobalsAndPackages() ... DONE
[21:39:01.920] run() for 'Future' ...
[21:39:01.921] - state: 'created'
[21:39:01.921] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[21:39:01.922] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:01.922] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:01.922] - Field: 'label'
[21:39:01.922] - Field: 'local'
[21:39:01.923] - Field: 'owner'
[21:39:01.923] - Field: 'envir'
[21:39:01.923] - Field: 'packages'
[21:39:01.923] - Field: 'gc'
[21:39:01.924] - Field: 'conditions'
[21:39:01.924] - Field: 'expr'
[21:39:01.924] - Field: 'uuid'
[21:39:01.924] - Field: 'seed'
[21:39:01.925] - Field: 'version'
[21:39:01.925] - Field: 'result'
[21:39:01.925] - Field: 'asynchronous'
[21:39:01.925] - Field: 'calls'
[21:39:01.925] - Field: 'globals'
[21:39:01.926] - Field: 'stdout'
[21:39:01.926] - Field: 'earlySignal'
[21:39:01.926] - Field: 'lazy'
[21:39:01.926] - Field: 'state'
[21:39:01.927] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:01.927] - Launch lazy future ...
[21:39:01.927] Packages needed by the future expression (n = 0): <none>
[21:39:01.928] Packages needed by future strategies (n = 0): <none>
[21:39:01.929] {
[21:39:01.929] {
[21:39:01.929] {
[21:39:01.929] ...future.startTime <- base::Sys.time()
[21:39:01.929] {
[21:39:01.929] {
[21:39:01.929] {
[21:39:01.929] base::local({
[21:39:01.929] has_future <- base::requireNamespace("future",
[21:39:01.929] quietly = TRUE)
[21:39:01.929] if (has_future) {
[21:39:01.929] ns <- base::getNamespace("future")
[21:39:01.929] version <- ns[[".package"]][["version"]]
[21:39:01.929] if (is.null(version))
[21:39:01.929] version <- utils::packageVersion("future")
[21:39:01.929] }
[21:39:01.929] else {
[21:39:01.929] version <- NULL
[21:39:01.929] }
[21:39:01.929] if (!has_future || version < "1.8.0") {
[21:39:01.929] info <- base::c(r_version = base::gsub("R version ",
[21:39:01.929] "", base::R.version$version.string),
[21:39:01.929] platform = base::sprintf("%s (%s-bit)",
[21:39:01.929] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:01.929] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:01.929] "release", "version")], collapse = " "),
[21:39:01.929] hostname = base::Sys.info()[["nodename"]])
[21:39:01.929] info <- base::sprintf("%s: %s", base::names(info),
[21:39:01.929] info)
[21:39:01.929] info <- base::paste(info, collapse = "; ")
[21:39:01.929] if (!has_future) {
[21:39:01.929] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:01.929] info)
[21:39:01.929] }
[21:39:01.929] else {
[21:39:01.929] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:01.929] info, version)
[21:39:01.929] }
[21:39:01.929] base::stop(msg)
[21:39:01.929] }
[21:39:01.929] })
[21:39:01.929] }
[21:39:01.929] options(future.plan = NULL)
[21:39:01.929] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:01.929] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:01.929] }
[21:39:01.929] ...future.workdir <- getwd()
[21:39:01.929] }
[21:39:01.929] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:01.929] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:01.929] }
[21:39:01.929] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:01.929] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:01.929] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:01.929] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:01.929] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:01.929] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:01.929] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:01.929] base::names(...future.oldOptions))
[21:39:01.929] }
[21:39:01.929] if (FALSE) {
[21:39:01.929] }
[21:39:01.929] else {
[21:39:01.929] if (TRUE) {
[21:39:01.929] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:01.929] open = "w")
[21:39:01.929] }
[21:39:01.929] else {
[21:39:01.929] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:01.929] windows = "NUL", "/dev/null"), open = "w")
[21:39:01.929] }
[21:39:01.929] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:01.929] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:01.929] base::sink(type = "output", split = FALSE)
[21:39:01.929] base::close(...future.stdout)
[21:39:01.929] }, add = TRUE)
[21:39:01.929] }
[21:39:01.929] ...future.frame <- base::sys.nframe()
[21:39:01.929] ...future.conditions <- base::list()
[21:39:01.929] ...future.rng <- base::globalenv()$.Random.seed
[21:39:01.929] if (FALSE) {
[21:39:01.929] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:01.929] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:01.929] }
[21:39:01.929] ...future.result <- base::tryCatch({
[21:39:01.929] base::withCallingHandlers({
[21:39:01.929] ...future.value <- base::withVisible(base::local({
[21:39:01.929] do.call(function(...) {
[21:39:01.929] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:01.929] if (!identical(...future.globals.maxSize.org,
[21:39:01.929] ...future.globals.maxSize)) {
[21:39:01.929] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:01.929] on.exit(options(oopts), add = TRUE)
[21:39:01.929] }
[21:39:01.929] {
[21:39:01.929] lapply(seq_along(...future.elements_ii),
[21:39:01.929] FUN = function(jj) {
[21:39:01.929] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:01.929] ...future.FUN(...future.X_jj, ...)
[21:39:01.929] })
[21:39:01.929] }
[21:39:01.929] }, args = future.call.arguments)
[21:39:01.929] }))
[21:39:01.929] future::FutureResult(value = ...future.value$value,
[21:39:01.929] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:01.929] ...future.rng), globalenv = if (FALSE)
[21:39:01.929] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:01.929] ...future.globalenv.names))
[21:39:01.929] else NULL, started = ...future.startTime, version = "1.8")
[21:39:01.929] }, condition = base::local({
[21:39:01.929] c <- base::c
[21:39:01.929] inherits <- base::inherits
[21:39:01.929] invokeRestart <- base::invokeRestart
[21:39:01.929] length <- base::length
[21:39:01.929] list <- base::list
[21:39:01.929] seq.int <- base::seq.int
[21:39:01.929] signalCondition <- base::signalCondition
[21:39:01.929] sys.calls <- base::sys.calls
[21:39:01.929] `[[` <- base::`[[`
[21:39:01.929] `+` <- base::`+`
[21:39:01.929] `<<-` <- base::`<<-`
[21:39:01.929] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:01.929] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:01.929] 3L)]
[21:39:01.929] }
[21:39:01.929] function(cond) {
[21:39:01.929] is_error <- inherits(cond, "error")
[21:39:01.929] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:01.929] NULL)
[21:39:01.929] if (is_error) {
[21:39:01.929] sessionInformation <- function() {
[21:39:01.929] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:01.929] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:01.929] search = base::search(), system = base::Sys.info())
[21:39:01.929] }
[21:39:01.929] ...future.conditions[[length(...future.conditions) +
[21:39:01.929] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:01.929] cond$call), session = sessionInformation(),
[21:39:01.929] timestamp = base::Sys.time(), signaled = 0L)
[21:39:01.929] signalCondition(cond)
[21:39:01.929] }
[21:39:01.929] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:01.929] "immediateCondition"))) {
[21:39:01.929] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:01.929] ...future.conditions[[length(...future.conditions) +
[21:39:01.929] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:01.929] if (TRUE && !signal) {
[21:39:01.929] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:01.929] {
[21:39:01.929] inherits <- base::inherits
[21:39:01.929] invokeRestart <- base::invokeRestart
[21:39:01.929] is.null <- base::is.null
[21:39:01.929] muffled <- FALSE
[21:39:01.929] if (inherits(cond, "message")) {
[21:39:01.929] muffled <- grepl(pattern, "muffleMessage")
[21:39:01.929] if (muffled)
[21:39:01.929] invokeRestart("muffleMessage")
[21:39:01.929] }
[21:39:01.929] else if (inherits(cond, "warning")) {
[21:39:01.929] muffled <- grepl(pattern, "muffleWarning")
[21:39:01.929] if (muffled)
[21:39:01.929] invokeRestart("muffleWarning")
[21:39:01.929] }
[21:39:01.929] else if (inherits(cond, "condition")) {
[21:39:01.929] if (!is.null(pattern)) {
[21:39:01.929] computeRestarts <- base::computeRestarts
[21:39:01.929] grepl <- base::grepl
[21:39:01.929] restarts <- computeRestarts(cond)
[21:39:01.929] for (restart in restarts) {
[21:39:01.929] name <- restart$name
[21:39:01.929] if (is.null(name))
[21:39:01.929] next
[21:39:01.929] if (!grepl(pattern, name))
[21:39:01.929] next
[21:39:01.929] invokeRestart(restart)
[21:39:01.929] muffled <- TRUE
[21:39:01.929] break
[21:39:01.929] }
[21:39:01.929] }
[21:39:01.929] }
[21:39:01.929] invisible(muffled)
[21:39:01.929] }
[21:39:01.929] muffleCondition(cond, pattern = "^muffle")
[21:39:01.929] }
[21:39:01.929] }
[21:39:01.929] else {
[21:39:01.929] if (TRUE) {
[21:39:01.929] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:01.929] {
[21:39:01.929] inherits <- base::inherits
[21:39:01.929] invokeRestart <- base::invokeRestart
[21:39:01.929] is.null <- base::is.null
[21:39:01.929] muffled <- FALSE
[21:39:01.929] if (inherits(cond, "message")) {
[21:39:01.929] muffled <- grepl(pattern, "muffleMessage")
[21:39:01.929] if (muffled)
[21:39:01.929] invokeRestart("muffleMessage")
[21:39:01.929] }
[21:39:01.929] else if (inherits(cond, "warning")) {
[21:39:01.929] muffled <- grepl(pattern, "muffleWarning")
[21:39:01.929] if (muffled)
[21:39:01.929] invokeRestart("muffleWarning")
[21:39:01.929] }
[21:39:01.929] else if (inherits(cond, "condition")) {
[21:39:01.929] if (!is.null(pattern)) {
[21:39:01.929] computeRestarts <- base::computeRestarts
[21:39:01.929] grepl <- base::grepl
[21:39:01.929] restarts <- computeRestarts(cond)
[21:39:01.929] for (restart in restarts) {
[21:39:01.929] name <- restart$name
[21:39:01.929] if (is.null(name))
[21:39:01.929] next
[21:39:01.929] if (!grepl(pattern, name))
[21:39:01.929] next
[21:39:01.929] invokeRestart(restart)
[21:39:01.929] muffled <- TRUE
[21:39:01.929] break
[21:39:01.929] }
[21:39:01.929] }
[21:39:01.929] }
[21:39:01.929] invisible(muffled)
[21:39:01.929] }
[21:39:01.929] muffleCondition(cond, pattern = "^muffle")
[21:39:01.929] }
[21:39:01.929] }
[21:39:01.929] }
[21:39:01.929] }))
[21:39:01.929] }, error = function(ex) {
[21:39:01.929] base::structure(base::list(value = NULL, visible = NULL,
[21:39:01.929] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:01.929] ...future.rng), started = ...future.startTime,
[21:39:01.929] finished = Sys.time(), session_uuid = NA_character_,
[21:39:01.929] version = "1.8"), class = "FutureResult")
[21:39:01.929] }, finally = {
[21:39:01.929] if (!identical(...future.workdir, getwd()))
[21:39:01.929] setwd(...future.workdir)
[21:39:01.929] {
[21:39:01.929] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:01.929] ...future.oldOptions$nwarnings <- NULL
[21:39:01.929] }
[21:39:01.929] base::options(...future.oldOptions)
[21:39:01.929] if (.Platform$OS.type == "windows") {
[21:39:01.929] old_names <- names(...future.oldEnvVars)
[21:39:01.929] envs <- base::Sys.getenv()
[21:39:01.929] names <- names(envs)
[21:39:01.929] common <- intersect(names, old_names)
[21:39:01.929] added <- setdiff(names, old_names)
[21:39:01.929] removed <- setdiff(old_names, names)
[21:39:01.929] changed <- common[...future.oldEnvVars[common] !=
[21:39:01.929] envs[common]]
[21:39:01.929] NAMES <- toupper(changed)
[21:39:01.929] args <- list()
[21:39:01.929] for (kk in seq_along(NAMES)) {
[21:39:01.929] name <- changed[[kk]]
[21:39:01.929] NAME <- NAMES[[kk]]
[21:39:01.929] if (name != NAME && is.element(NAME, old_names))
[21:39:01.929] next
[21:39:01.929] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:01.929] }
[21:39:01.929] NAMES <- toupper(added)
[21:39:01.929] for (kk in seq_along(NAMES)) {
[21:39:01.929] name <- added[[kk]]
[21:39:01.929] NAME <- NAMES[[kk]]
[21:39:01.929] if (name != NAME && is.element(NAME, old_names))
[21:39:01.929] next
[21:39:01.929] args[[name]] <- ""
[21:39:01.929] }
[21:39:01.929] NAMES <- toupper(removed)
[21:39:01.929] for (kk in seq_along(NAMES)) {
[21:39:01.929] name <- removed[[kk]]
[21:39:01.929] NAME <- NAMES[[kk]]
[21:39:01.929] if (name != NAME && is.element(NAME, old_names))
[21:39:01.929] next
[21:39:01.929] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:01.929] }
[21:39:01.929] if (length(args) > 0)
[21:39:01.929] base::do.call(base::Sys.setenv, args = args)
[21:39:01.929] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:01.929] }
[21:39:01.929] else {
[21:39:01.929] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:01.929] }
[21:39:01.929] {
[21:39:01.929] if (base::length(...future.futureOptionsAdded) >
[21:39:01.929] 0L) {
[21:39:01.929] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:01.929] base::names(opts) <- ...future.futureOptionsAdded
[21:39:01.929] base::options(opts)
[21:39:01.929] }
[21:39:01.929] {
[21:39:01.929] {
[21:39:01.929] NULL
[21:39:01.929] RNGkind("Mersenne-Twister")
[21:39:01.929] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:01.929] inherits = FALSE)
[21:39:01.929] }
[21:39:01.929] options(future.plan = NULL)
[21:39:01.929] if (is.na(NA_character_))
[21:39:01.929] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:01.929] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:01.929] future::plan(list(function (..., envir = parent.frame())
[21:39:01.929] {
[21:39:01.929] future <- SequentialFuture(..., envir = envir)
[21:39:01.929] if (!future$lazy)
[21:39:01.929] future <- run(future)
[21:39:01.929] invisible(future)
[21:39:01.929] }), .cleanup = FALSE, .init = FALSE)
[21:39:01.929] }
[21:39:01.929] }
[21:39:01.929] }
[21:39:01.929] })
[21:39:01.929] if (TRUE) {
[21:39:01.929] base::sink(type = "output", split = FALSE)
[21:39:01.929] if (TRUE) {
[21:39:01.929] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:01.929] }
[21:39:01.929] else {
[21:39:01.929] ...future.result["stdout"] <- base::list(NULL)
[21:39:01.929] }
[21:39:01.929] base::close(...future.stdout)
[21:39:01.929] ...future.stdout <- NULL
[21:39:01.929] }
[21:39:01.929] ...future.result$conditions <- ...future.conditions
[21:39:01.929] ...future.result$finished <- base::Sys.time()
[21:39:01.929] ...future.result
[21:39:01.929] }
[21:39:01.949] assign_globals() ...
[21:39:01.949] List of 5
[21:39:01.949] $ ...future.FUN :function (x)
[21:39:01.949] $ future.call.arguments : list()
[21:39:01.949] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:01.949] $ ...future.elements_ii :List of 2
[21:39:01.949] ..$ : int 1
[21:39:01.949] ..$ : int 0
[21:39:01.949] $ ...future.seeds_ii : NULL
[21:39:01.949] $ ...future.globals.maxSize: NULL
[21:39:01.949] - attr(*, "resolved")= logi FALSE
[21:39:01.949] - attr(*, "total_size")= num 4720
[21:39:01.949] - attr(*, "where")=List of 5
[21:39:01.949] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:01.949] ..$ future.call.arguments :<environment: R_EmptyEnv>
[21:39:01.949] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:01.949] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:01.949] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:01.949] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:01.949] - attr(*, "already-done")= logi TRUE
[21:39:01.961] - reassign environment for '...future.FUN'
[21:39:01.961] - copied '...future.FUN' to environment
[21:39:01.961] - copied 'future.call.arguments' to environment
[21:39:01.961] - copied '...future.elements_ii' to environment
[21:39:01.962] - copied '...future.seeds_ii' to environment
[21:39:01.962] - copied '...future.globals.maxSize' to environment
[21:39:01.962] assign_globals() ... done
[21:39:01.979] plan(): Setting new future strategy stack:
[21:39:01.979] List of future strategies:
[21:39:01.979] 1. sequential:
[21:39:01.979] - args: function (..., envir = parent.frame())
[21:39:01.979] - tweaked: FALSE
[21:39:01.979] - call: NULL
[21:39:01.980] plan(): nbrOfWorkers() = 1
[21:39:02.482] plan(): Setting new future strategy stack:
[21:39:02.483] List of future strategies:
[21:39:02.483] 1. sequential:
[21:39:02.483] - args: function (..., envir = parent.frame())
[21:39:02.483] - tweaked: FALSE
[21:39:02.483] - call: plan(strategy)
[21:39:02.483] plan(): nbrOfWorkers() = 1
[21:39:02.484] SequentialFuture started (and completed)
[21:39:02.484] - Launch lazy future ... done
[21:39:02.484] run() for 'SequentialFuture' ... done
[21:39:02.485] Created future:
[21:39:02.485] SequentialFuture:
[21:39:02.485] Label: 'future_lapply-1'
[21:39:02.485] Expression:
[21:39:02.485] {
[21:39:02.485] do.call(function(...) {
[21:39:02.485] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:02.485] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:02.485] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:02.485] on.exit(options(oopts), add = TRUE)
[21:39:02.485] }
[21:39:02.485] {
[21:39:02.485] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:02.485] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:02.485] ...future.FUN(...future.X_jj, ...)
[21:39:02.485] })
[21:39:02.485] }
[21:39:02.485] }, args = future.call.arguments)
[21:39:02.485] }
[21:39:02.485] Lazy evaluation: FALSE
[21:39:02.485] Asynchronous evaluation: FALSE
[21:39:02.485] Local evaluation: TRUE
[21:39:02.485] Environment: R_GlobalEnv
[21:39:02.485] Capture standard output: TRUE
[21:39:02.485] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:02.485] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:02.485] Packages: <none>
[21:39:02.485] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:02.485] Resolved: TRUE
[21:39:02.485] Value: 112 bytes of class 'list'
[21:39:02.485] Early signaling: FALSE
[21:39:02.485] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:02.485] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:02.487] Chunk #1 of 1 ... DONE
[21:39:02.487] Launching 1 futures (chunks) ... DONE
[21:39:02.488] Resolving 1 futures (chunks) ...
[21:39:02.488] resolve() on list ...
[21:39:02.488] recursive: 0
[21:39:02.488] length: 1
[21:39:02.488]
[21:39:02.489] resolved() for 'SequentialFuture' ...
[21:39:02.489] - state: 'finished'
[21:39:02.489] - run: TRUE
[21:39:02.489] - result: 'FutureResult'
[21:39:02.489] resolved() for 'SequentialFuture' ... done
[21:39:02.490] Future #1
[21:39:02.490] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:02.490] - nx: 1
[21:39:02.490] - relay: TRUE
[21:39:02.491] - stdout: TRUE
[21:39:02.491] - signal: TRUE
[21:39:02.491] - resignal: FALSE
[21:39:02.491] - force: TRUE
[21:39:02.492] - relayed: [n=1] FALSE
[21:39:02.492] - queued futures: [n=1] FALSE
[21:39:02.492] - until=1
[21:39:02.492] - relaying element #1
[21:39:02.493] - relayed: [n=1] TRUE
[21:39:02.493] - queued futures: [n=1] TRUE
[21:39:02.493] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:02.493] length: 0 (resolved future 1)
[21:39:02.494] Relaying remaining futures
[21:39:02.494] signalConditionsASAP(NULL, pos=0) ...
[21:39:02.494] - nx: 1
[21:39:02.494] - relay: TRUE
[21:39:02.495] - stdout: TRUE
[21:39:02.495] - signal: TRUE
[21:39:02.495] - resignal: FALSE
[21:39:02.499] - force: TRUE
[21:39:02.499] - relayed: [n=1] TRUE
[21:39:02.499] - queued futures: [n=1] TRUE
- flush all
[21:39:02.499] - relayed: [n=1] TRUE
[21:39:02.500] - queued futures: [n=1] TRUE
[21:39:02.500] signalConditionsASAP(NULL, pos=0) ... done
[21:39:02.500] resolve() on list ... DONE
[21:39:02.501] - Number of value chunks collected: 1
[21:39:02.501] Resolving 1 futures (chunks) ... DONE
[21:39:02.501] Reducing values from 1 chunks ...
[21:39:02.501] - Number of values collected after concatenation: 2
[21:39:02.501] - Number of values expected: 2
[21:39:02.502] Reducing values from 1 chunks ... DONE
[21:39:02.502] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ... DONE
* future_lapply(x, ..., future.stdout = NA) ...
[21:39:02.503] future_lapply() ...
[21:39:02.504] Number of chunks: 1
[21:39:02.504] getGlobalsAndPackagesXApply() ...
[21:39:02.505] - future.globals: TRUE
[21:39:02.505] getGlobalsAndPackages() ...
[21:39:02.505] Searching for globals...
[21:39:02.512] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[21:39:02.512] Searching for globals ... DONE
[21:39:02.512] Resolving globals: FALSE
[21:39:02.513] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[21:39:02.514] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[21:39:02.514] - globals: [1] 'FUN'
[21:39:02.514]
[21:39:02.514] getGlobalsAndPackages() ... DONE
[21:39:02.515] - globals found/used: [n=1] 'FUN'
[21:39:02.515] - needed namespaces: [n=0]
[21:39:02.515] Finding globals ... DONE
[21:39:02.515] - use_args: TRUE
[21:39:02.515] - Getting '...' globals ...
[21:39:02.516] resolve() on list ...
[21:39:02.516] recursive: 0
[21:39:02.517] length: 1
[21:39:02.517] elements: '...'
[21:39:02.517] length: 0 (resolved future 1)
[21:39:02.517] resolve() on list ... DONE
[21:39:02.518] - '...' content: [n=0]
[21:39:02.518] List of 1
[21:39:02.518] $ ...: list()
[21:39:02.518] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:02.518] - attr(*, "where")=List of 1
[21:39:02.518] ..$ ...:<environment: 0x55c1f08adcc8>
[21:39:02.518] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:02.518] - attr(*, "resolved")= logi TRUE
[21:39:02.518] - attr(*, "total_size")= num NA
[21:39:02.523] - Getting '...' globals ... DONE
[21:39:02.524] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[21:39:02.524] List of 2
[21:39:02.524] $ ...future.FUN:function (x)
[21:39:02.524] $ ... : list()
[21:39:02.524] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:02.524] - attr(*, "where")=List of 2
[21:39:02.524] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:02.524] ..$ ... :<environment: 0x55c1f08adcc8>
[21:39:02.524] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:02.524] - attr(*, "resolved")= logi FALSE
[21:39:02.524] - attr(*, "total_size")= num 4720
[21:39:02.539] Packages to be attached in all futures: [n=0]
[21:39:02.539] getGlobalsAndPackagesXApply() ... DONE
[21:39:02.540] Number of futures (= number of chunks): 1
[21:39:02.540] Launching 1 futures (chunks) ...
[21:39:02.540] Chunk #1 of 1 ...
[21:39:02.540] - Finding globals in 'X' for chunk #1 ...
[21:39:02.541] getGlobalsAndPackages() ...
[21:39:02.541] Searching for globals...
[21:39:02.541]
[21:39:02.542] Searching for globals ... DONE
[21:39:02.542] - globals: [0] <none>
[21:39:02.542] getGlobalsAndPackages() ... DONE
[21:39:02.542] + additional globals found: [n=0]
[21:39:02.542] + additional namespaces needed: [n=0]
[21:39:02.543] - Finding globals in 'X' for chunk #1 ... DONE
[21:39:02.543] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:02.543] - seeds: <none>
[21:39:02.543] getGlobalsAndPackages() ...
[21:39:02.544] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:02.544] Resolving globals: FALSE
[21:39:02.544] Tweak future expression to call with '...' arguments ...
[21:39:02.544] {
[21:39:02.544] do.call(function(...) {
[21:39:02.544] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:02.544] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:02.544] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:02.544] on.exit(options(oopts), add = TRUE)
[21:39:02.544] }
[21:39:02.544] {
[21:39:02.544] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:02.544] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:02.544] ...future.FUN(...future.X_jj, ...)
[21:39:02.544] })
[21:39:02.544] }
[21:39:02.544] }, args = future.call.arguments)
[21:39:02.544] }
[21:39:02.545] Tweak future expression to call with '...' arguments ... DONE
[21:39:02.546] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:02.546]
[21:39:02.546] getGlobalsAndPackages() ... DONE
[21:39:02.547] run() for 'Future' ...
[21:39:02.547] - state: 'created'
[21:39:02.547] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[21:39:02.548] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:02.548] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:02.549] - Field: 'label'
[21:39:02.549] - Field: 'local'
[21:39:02.549] - Field: 'owner'
[21:39:02.549] - Field: 'envir'
[21:39:02.549] - Field: 'packages'
[21:39:02.550] - Field: 'gc'
[21:39:02.550] - Field: 'conditions'
[21:39:02.550] - Field: 'expr'
[21:39:02.550] - Field: 'uuid'
[21:39:02.550] - Field: 'seed'
[21:39:02.553] - Field: 'version'
[21:39:02.553] - Field: 'result'
[21:39:02.553] - Field: 'asynchronous'
[21:39:02.554] - Field: 'calls'
[21:39:02.554] - Field: 'globals'
[21:39:02.554] - Field: 'stdout'
[21:39:02.554] - Field: 'earlySignal'
[21:39:02.554] - Field: 'lazy'
[21:39:02.555] - Field: 'state'
[21:39:02.555] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:02.555] - Launch lazy future ...
[21:39:02.556] Packages needed by the future expression (n = 0): <none>
[21:39:02.556] Packages needed by future strategies (n = 0): <none>
[21:39:02.557] {
[21:39:02.557] {
[21:39:02.557] {
[21:39:02.557] ...future.startTime <- base::Sys.time()
[21:39:02.557] {
[21:39:02.557] {
[21:39:02.557] {
[21:39:02.557] base::local({
[21:39:02.557] has_future <- base::requireNamespace("future",
[21:39:02.557] quietly = TRUE)
[21:39:02.557] if (has_future) {
[21:39:02.557] ns <- base::getNamespace("future")
[21:39:02.557] version <- ns[[".package"]][["version"]]
[21:39:02.557] if (is.null(version))
[21:39:02.557] version <- utils::packageVersion("future")
[21:39:02.557] }
[21:39:02.557] else {
[21:39:02.557] version <- NULL
[21:39:02.557] }
[21:39:02.557] if (!has_future || version < "1.8.0") {
[21:39:02.557] info <- base::c(r_version = base::gsub("R version ",
[21:39:02.557] "", base::R.version$version.string),
[21:39:02.557] platform = base::sprintf("%s (%s-bit)",
[21:39:02.557] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:02.557] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:02.557] "release", "version")], collapse = " "),
[21:39:02.557] hostname = base::Sys.info()[["nodename"]])
[21:39:02.557] info <- base::sprintf("%s: %s", base::names(info),
[21:39:02.557] info)
[21:39:02.557] info <- base::paste(info, collapse = "; ")
[21:39:02.557] if (!has_future) {
[21:39:02.557] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:02.557] info)
[21:39:02.557] }
[21:39:02.557] else {
[21:39:02.557] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:02.557] info, version)
[21:39:02.557] }
[21:39:02.557] base::stop(msg)
[21:39:02.557] }
[21:39:02.557] })
[21:39:02.557] }
[21:39:02.557] options(future.plan = NULL)
[21:39:02.557] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:02.557] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:02.557] }
[21:39:02.557] ...future.workdir <- getwd()
[21:39:02.557] }
[21:39:02.557] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:02.557] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:02.557] }
[21:39:02.557] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:02.557] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:02.557] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:02.557] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:02.557] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:02.557] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:02.557] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:02.557] base::names(...future.oldOptions))
[21:39:02.557] }
[21:39:02.557] if (TRUE) {
[21:39:02.557] }
[21:39:02.557] else {
[21:39:02.557] if (NA) {
[21:39:02.557] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:02.557] open = "w")
[21:39:02.557] }
[21:39:02.557] else {
[21:39:02.557] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:02.557] windows = "NUL", "/dev/null"), open = "w")
[21:39:02.557] }
[21:39:02.557] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:02.557] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:02.557] base::sink(type = "output", split = FALSE)
[21:39:02.557] base::close(...future.stdout)
[21:39:02.557] }, add = TRUE)
[21:39:02.557] }
[21:39:02.557] ...future.frame <- base::sys.nframe()
[21:39:02.557] ...future.conditions <- base::list()
[21:39:02.557] ...future.rng <- base::globalenv()$.Random.seed
[21:39:02.557] if (FALSE) {
[21:39:02.557] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:02.557] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:02.557] }
[21:39:02.557] ...future.result <- base::tryCatch({
[21:39:02.557] base::withCallingHandlers({
[21:39:02.557] ...future.value <- base::withVisible(base::local({
[21:39:02.557] do.call(function(...) {
[21:39:02.557] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:02.557] if (!identical(...future.globals.maxSize.org,
[21:39:02.557] ...future.globals.maxSize)) {
[21:39:02.557] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:02.557] on.exit(options(oopts), add = TRUE)
[21:39:02.557] }
[21:39:02.557] {
[21:39:02.557] lapply(seq_along(...future.elements_ii),
[21:39:02.557] FUN = function(jj) {
[21:39:02.557] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:02.557] ...future.FUN(...future.X_jj, ...)
[21:39:02.557] })
[21:39:02.557] }
[21:39:02.557] }, args = future.call.arguments)
[21:39:02.557] }))
[21:39:02.557] future::FutureResult(value = ...future.value$value,
[21:39:02.557] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:02.557] ...future.rng), globalenv = if (FALSE)
[21:39:02.557] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:02.557] ...future.globalenv.names))
[21:39:02.557] else NULL, started = ...future.startTime, version = "1.8")
[21:39:02.557] }, condition = base::local({
[21:39:02.557] c <- base::c
[21:39:02.557] inherits <- base::inherits
[21:39:02.557] invokeRestart <- base::invokeRestart
[21:39:02.557] length <- base::length
[21:39:02.557] list <- base::list
[21:39:02.557] seq.int <- base::seq.int
[21:39:02.557] signalCondition <- base::signalCondition
[21:39:02.557] sys.calls <- base::sys.calls
[21:39:02.557] `[[` <- base::`[[`
[21:39:02.557] `+` <- base::`+`
[21:39:02.557] `<<-` <- base::`<<-`
[21:39:02.557] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:02.557] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:02.557] 3L)]
[21:39:02.557] }
[21:39:02.557] function(cond) {
[21:39:02.557] is_error <- inherits(cond, "error")
[21:39:02.557] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:02.557] NULL)
[21:39:02.557] if (is_error) {
[21:39:02.557] sessionInformation <- function() {
[21:39:02.557] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:02.557] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:02.557] search = base::search(), system = base::Sys.info())
[21:39:02.557] }
[21:39:02.557] ...future.conditions[[length(...future.conditions) +
[21:39:02.557] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:02.557] cond$call), session = sessionInformation(),
[21:39:02.557] timestamp = base::Sys.time(), signaled = 0L)
[21:39:02.557] signalCondition(cond)
[21:39:02.557] }
[21:39:02.557] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:02.557] "immediateCondition"))) {
[21:39:02.557] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:02.557] ...future.conditions[[length(...future.conditions) +
[21:39:02.557] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:02.557] if (TRUE && !signal) {
[21:39:02.557] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:02.557] {
[21:39:02.557] inherits <- base::inherits
[21:39:02.557] invokeRestart <- base::invokeRestart
[21:39:02.557] is.null <- base::is.null
[21:39:02.557] muffled <- FALSE
[21:39:02.557] if (inherits(cond, "message")) {
[21:39:02.557] muffled <- grepl(pattern, "muffleMessage")
[21:39:02.557] if (muffled)
[21:39:02.557] invokeRestart("muffleMessage")
[21:39:02.557] }
[21:39:02.557] else if (inherits(cond, "warning")) {
[21:39:02.557] muffled <- grepl(pattern, "muffleWarning")
[21:39:02.557] if (muffled)
[21:39:02.557] invokeRestart("muffleWarning")
[21:39:02.557] }
[21:39:02.557] else if (inherits(cond, "condition")) {
[21:39:02.557] if (!is.null(pattern)) {
[21:39:02.557] computeRestarts <- base::computeRestarts
[21:39:02.557] grepl <- base::grepl
[21:39:02.557] restarts <- computeRestarts(cond)
[21:39:02.557] for (restart in restarts) {
[21:39:02.557] name <- restart$name
[21:39:02.557] if (is.null(name))
[21:39:02.557] next
[21:39:02.557] if (!grepl(pattern, name))
[21:39:02.557] next
[21:39:02.557] invokeRestart(restart)
[21:39:02.557] muffled <- TRUE
[21:39:02.557] break
[21:39:02.557] }
[21:39:02.557] }
[21:39:02.557] }
[21:39:02.557] invisible(muffled)
[21:39:02.557] }
[21:39:02.557] muffleCondition(cond, pattern = "^muffle")
[21:39:02.557] }
[21:39:02.557] }
[21:39:02.557] else {
[21:39:02.557] if (TRUE) {
[21:39:02.557] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:02.557] {
[21:39:02.557] inherits <- base::inherits
[21:39:02.557] invokeRestart <- base::invokeRestart
[21:39:02.557] is.null <- base::is.null
[21:39:02.557] muffled <- FALSE
[21:39:02.557] if (inherits(cond, "message")) {
[21:39:02.557] muffled <- grepl(pattern, "muffleMessage")
[21:39:02.557] if (muffled)
[21:39:02.557] invokeRestart("muffleMessage")
[21:39:02.557] }
[21:39:02.557] else if (inherits(cond, "warning")) {
[21:39:02.557] muffled <- grepl(pattern, "muffleWarning")
[21:39:02.557] if (muffled)
[21:39:02.557] invokeRestart("muffleWarning")
[21:39:02.557] }
[21:39:02.557] else if (inherits(cond, "condition")) {
[21:39:02.557] if (!is.null(pattern)) {
[21:39:02.557] computeRestarts <- base::computeRestarts
[21:39:02.557] grepl <- base::grepl
[21:39:02.557] restarts <- computeRestarts(cond)
[21:39:02.557] for (restart in restarts) {
[21:39:02.557] name <- restart$name
[21:39:02.557] if (is.null(name))
[21:39:02.557] next
[21:39:02.557] if (!grepl(pattern, name))
[21:39:02.557] next
[21:39:02.557] invokeRestart(restart)
[21:39:02.557] muffled <- TRUE
[21:39:02.557] break
[21:39:02.557] }
[21:39:02.557] }
[21:39:02.557] }
[21:39:02.557] invisible(muffled)
[21:39:02.557] }
[21:39:02.557] muffleCondition(cond, pattern = "^muffle")
[21:39:02.557] }
[21:39:02.557] }
[21:39:02.557] }
[21:39:02.557] }))
[21:39:02.557] }, error = function(ex) {
[21:39:02.557] base::structure(base::list(value = NULL, visible = NULL,
[21:39:02.557] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:02.557] ...future.rng), started = ...future.startTime,
[21:39:02.557] finished = Sys.time(), session_uuid = NA_character_,
[21:39:02.557] version = "1.8"), class = "FutureResult")
[21:39:02.557] }, finally = {
[21:39:02.557] if (!identical(...future.workdir, getwd()))
[21:39:02.557] setwd(...future.workdir)
[21:39:02.557] {
[21:39:02.557] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:02.557] ...future.oldOptions$nwarnings <- NULL
[21:39:02.557] }
[21:39:02.557] base::options(...future.oldOptions)
[21:39:02.557] if (.Platform$OS.type == "windows") {
[21:39:02.557] old_names <- names(...future.oldEnvVars)
[21:39:02.557] envs <- base::Sys.getenv()
[21:39:02.557] names <- names(envs)
[21:39:02.557] common <- intersect(names, old_names)
[21:39:02.557] added <- setdiff(names, old_names)
[21:39:02.557] removed <- setdiff(old_names, names)
[21:39:02.557] changed <- common[...future.oldEnvVars[common] !=
[21:39:02.557] envs[common]]
[21:39:02.557] NAMES <- toupper(changed)
[21:39:02.557] args <- list()
[21:39:02.557] for (kk in seq_along(NAMES)) {
[21:39:02.557] name <- changed[[kk]]
[21:39:02.557] NAME <- NAMES[[kk]]
[21:39:02.557] if (name != NAME && is.element(NAME, old_names))
[21:39:02.557] next
[21:39:02.557] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:02.557] }
[21:39:02.557] NAMES <- toupper(added)
[21:39:02.557] for (kk in seq_along(NAMES)) {
[21:39:02.557] name <- added[[kk]]
[21:39:02.557] NAME <- NAMES[[kk]]
[21:39:02.557] if (name != NAME && is.element(NAME, old_names))
[21:39:02.557] next
[21:39:02.557] args[[name]] <- ""
[21:39:02.557] }
[21:39:02.557] NAMES <- toupper(removed)
[21:39:02.557] for (kk in seq_along(NAMES)) {
[21:39:02.557] name <- removed[[kk]]
[21:39:02.557] NAME <- NAMES[[kk]]
[21:39:02.557] if (name != NAME && is.element(NAME, old_names))
[21:39:02.557] next
[21:39:02.557] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:02.557] }
[21:39:02.557] if (length(args) > 0)
[21:39:02.557] base::do.call(base::Sys.setenv, args = args)
[21:39:02.557] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:02.557] }
[21:39:02.557] else {
[21:39:02.557] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:02.557] }
[21:39:02.557] {
[21:39:02.557] if (base::length(...future.futureOptionsAdded) >
[21:39:02.557] 0L) {
[21:39:02.557] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:02.557] base::names(opts) <- ...future.futureOptionsAdded
[21:39:02.557] base::options(opts)
[21:39:02.557] }
[21:39:02.557] {
[21:39:02.557] {
[21:39:02.557] NULL
[21:39:02.557] RNGkind("Mersenne-Twister")
[21:39:02.557] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:02.557] inherits = FALSE)
[21:39:02.557] }
[21:39:02.557] options(future.plan = NULL)
[21:39:02.557] if (is.na(NA_character_))
[21:39:02.557] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:02.557] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:02.557] future::plan(list(function (..., envir = parent.frame())
[21:39:02.557] {
[21:39:02.557] future <- SequentialFuture(..., envir = envir)
[21:39:02.557] if (!future$lazy)
[21:39:02.557] future <- run(future)
[21:39:02.557] invisible(future)
[21:39:02.557] }), .cleanup = FALSE, .init = FALSE)
[21:39:02.557] }
[21:39:02.557] }
[21:39:02.557] }
[21:39:02.557] })
[21:39:02.557] if (FALSE) {
[21:39:02.557] base::sink(type = "output", split = FALSE)
[21:39:02.557] if (NA) {
[21:39:02.557] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:02.557] }
[21:39:02.557] else {
[21:39:02.557] ...future.result["stdout"] <- base::list(NULL)
[21:39:02.557] }
[21:39:02.557] base::close(...future.stdout)
[21:39:02.557] ...future.stdout <- NULL
[21:39:02.557] }
[21:39:02.557] ...future.result$conditions <- ...future.conditions
[21:39:02.557] ...future.result$finished <- base::Sys.time()
[21:39:02.557] ...future.result
[21:39:02.557] }
[21:39:02.560] assign_globals() ...
[21:39:02.561] List of 5
[21:39:02.561] $ ...future.FUN :function (x)
[21:39:02.561] $ future.call.arguments : list()
[21:39:02.561] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:02.561] $ ...future.elements_ii :List of 2
[21:39:02.561] ..$ : int 1
[21:39:02.561] ..$ : int 0
[21:39:02.561] $ ...future.seeds_ii : NULL
[21:39:02.561] $ ...future.globals.maxSize: NULL
[21:39:02.561] - attr(*, "resolved")= logi FALSE
[21:39:02.561] - attr(*, "total_size")= num 4720
[21:39:02.561] - attr(*, "where")=List of 5
[21:39:02.561] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:02.561] ..$ future.call.arguments :<environment: R_EmptyEnv>
[21:39:02.561] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:02.561] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:02.561] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:02.561] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:02.561] - attr(*, "already-done")= logi TRUE
[21:39:02.576] - reassign environment for '...future.FUN'
[21:39:02.577] - copied '...future.FUN' to environment
[21:39:02.577] - copied 'future.call.arguments' to environment
[21:39:02.577] - copied '...future.elements_ii' to environment
[21:39:02.577] - copied '...future.seeds_ii' to environment
[21:39:02.578] - copied '...future.globals.maxSize' to environment
[21:39:02.578] assign_globals() ... done
[21:39:02.578] plan(): Setting new future strategy stack:
[21:39:02.579] List of future strategies:
[21:39:02.579] 1. sequential:
[21:39:02.579] - args: function (..., envir = parent.frame())
[21:39:02.579] - tweaked: FALSE
[21:39:02.579] - call: NULL
[21:39:02.579] plan(): nbrOfWorkers() = 1
[21:39:03.082] plan(): Setting new future strategy stack:
[21:39:03.082] List of future strategies:
[21:39:03.082] 1. sequential:
[21:39:03.082] - args: function (..., envir = parent.frame())
[21:39:03.082] - tweaked: FALSE
[21:39:03.082] - call: plan(strategy)
[21:39:03.083] plan(): nbrOfWorkers() = 1
[21:39:03.083] SequentialFuture started (and completed)
[21:39:03.084] - Launch lazy future ... done
[21:39:03.084] run() for 'SequentialFuture' ... done
[21:39:03.084] Created future:
[21:39:03.084] SequentialFuture:
[21:39:03.084] Label: 'future_lapply-1'
[21:39:03.084] Expression:
[21:39:03.084] {
[21:39:03.084] do.call(function(...) {
[21:39:03.084] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:03.084] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:03.084] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:03.084] on.exit(options(oopts), add = TRUE)
[21:39:03.084] }
[21:39:03.084] {
[21:39:03.084] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:03.084] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:03.084] ...future.FUN(...future.X_jj, ...)
[21:39:03.084] })
[21:39:03.084] }
[21:39:03.084] }, args = future.call.arguments)
[21:39:03.084] }
[21:39:03.084] Lazy evaluation: FALSE
[21:39:03.084] Asynchronous evaluation: FALSE
[21:39:03.084] Local evaluation: TRUE
[21:39:03.084] Environment: R_GlobalEnv
[21:39:03.084] Capture standard output: NA
[21:39:03.084] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:03.084] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:03.084] Packages: <none>
[21:39:03.084] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:03.084] Resolved: TRUE
[21:39:03.084] Value: 112 bytes of class 'list'
[21:39:03.084] Early signaling: FALSE
[21:39:03.084] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:03.084] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:03.087] Chunk #1 of 1 ... DONE
[21:39:03.087] Launching 1 futures (chunks) ... DONE
[21:39:03.087] Resolving 1 futures (chunks) ...
[21:39:03.087] resolve() on list ...
[21:39:03.088] recursive: 0
[21:39:03.088] length: 1
[21:39:03.088]
[21:39:03.088] resolved() for 'SequentialFuture' ...
[21:39:03.088] - state: 'finished'
[21:39:03.089] - run: TRUE
[21:39:03.089] - result: 'FutureResult'
[21:39:03.089] resolved() for 'SequentialFuture' ... done
[21:39:03.089] Future #1
[21:39:03.090] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:03.090] - nx: 1
[21:39:03.090] - relay: TRUE
[21:39:03.090] - stdout: TRUE
[21:39:03.091] - signal: TRUE
[21:39:03.091] - resignal: FALSE
[21:39:03.091] - force: TRUE
[21:39:03.091] - relayed: [n=1] FALSE
[21:39:03.092] - queued futures: [n=1] FALSE
[21:39:03.092] - until=1
[21:39:03.092] - relaying element #1
[21:39:03.092] - relayed: [n=1] TRUE
[21:39:03.093] - queued futures: [n=1] TRUE
[21:39:03.093] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:03.093] length: 0 (resolved future 1)
[21:39:03.093] Relaying remaining futures
[21:39:03.094] signalConditionsASAP(NULL, pos=0) ...
[21:39:03.094] - nx: 1
[21:39:03.094] - relay: TRUE
[21:39:03.094] - stdout: TRUE
[21:39:03.106] - signal: TRUE
[21:39:03.107] - resignal: FALSE
[21:39:03.107] - force: TRUE
[21:39:03.107] - relayed: [n=1] TRUE
[21:39:03.107] - queued futures: [n=1] TRUE
- flush all
[21:39:03.108] - relayed: [n=1] TRUE
[21:39:03.108] - queued futures: [n=1] TRUE
[21:39:03.108] signalConditionsASAP(NULL, pos=0) ... done
[21:39:03.109] resolve() on list ... DONE
[21:39:03.109] - Number of value chunks collected: 1
[21:39:03.109] Resolving 1 futures (chunks) ... DONE
[21:39:03.109] Reducing values from 1 chunks ...
[21:39:03.110] - Number of values collected after concatenation: 2
[21:39:03.110] - Number of values expected: 2
[21:39:03.110] Reducing values from 1 chunks ... DONE
[21:39:03.110] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = NA) ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ...
[21:39:03.111] future_mapply() ...
[21:39:03.112] Number of chunks: 1
[21:39:03.112] getGlobalsAndPackagesXApply() ...
[21:39:03.112] - future.globals: TRUE
[21:39:03.112] getGlobalsAndPackages() ...
[21:39:03.113] Searching for globals...
[21:39:03.118] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[21:39:03.118] Searching for globals ... DONE
[21:39:03.119] Resolving globals: FALSE
[21:39:03.120] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[21:39:03.120] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[21:39:03.121] - globals: [1] 'FUN'
[21:39:03.121]
[21:39:03.121] getGlobalsAndPackages() ... DONE
[21:39:03.121] - globals found/used: [n=1] 'FUN'
[21:39:03.121] - needed namespaces: [n=0]
[21:39:03.122] Finding globals ... DONE
[21:39:03.122] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[21:39:03.122] List of 2
[21:39:03.122] $ ...future.FUN:function (x, y)
[21:39:03.122] $ MoreArgs : NULL
[21:39:03.122] - attr(*, "where")=List of 2
[21:39:03.122] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:03.122] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:03.122] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:03.122] - attr(*, "resolved")= logi FALSE
[21:39:03.122] - attr(*, "total_size")= num NA
[21:39:03.136] Packages to be attached in all futures: [n=0]
[21:39:03.137] getGlobalsAndPackagesXApply() ... DONE
[21:39:03.137] Number of futures (= number of chunks): 1
[21:39:03.137] Launching 1 futures (chunks) ...
[21:39:03.138] Chunk #1 of 1 ...
[21:39:03.138] - Finding globals in '...' for chunk #1 ...
[21:39:03.138] getGlobalsAndPackages() ...
[21:39:03.138] Searching for globals...
[21:39:03.139]
[21:39:03.139] Searching for globals ... DONE
[21:39:03.140] - globals: [0] <none>
[21:39:03.140] getGlobalsAndPackages() ... DONE
[21:39:03.140] + additional globals found: [n=0]
[21:39:03.140] + additional namespaces needed: [n=0]
[21:39:03.140] - Finding globals in '...' for chunk #1 ... DONE
[21:39:03.141] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:03.141] - seeds: <none>
[21:39:03.141] getGlobalsAndPackages() ...
[21:39:03.141] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:03.142] Resolving globals: FALSE
[21:39:03.151] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[21:39:03.152] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[21:39:03.152] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:03.153]
[21:39:03.153] getGlobalsAndPackages() ... DONE
[21:39:03.154] run() for 'Future' ...
[21:39:03.154] - state: 'created'
[21:39:03.154] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[21:39:03.163] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:03.163] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:03.164] - Field: 'label'
[21:39:03.164] - Field: 'local'
[21:39:03.164] - Field: 'owner'
[21:39:03.164] - Field: 'envir'
[21:39:03.164] - Field: 'packages'
[21:39:03.165] - Field: 'gc'
[21:39:03.165] - Field: 'conditions'
[21:39:03.165] - Field: 'expr'
[21:39:03.165] - Field: 'uuid'
[21:39:03.166] - Field: 'seed'
[21:39:03.166] - Field: 'version'
[21:39:03.166] - Field: 'result'
[21:39:03.169] - Field: 'asynchronous'
[21:39:03.170] - Field: 'calls'
[21:39:03.170] - Field: 'globals'
[21:39:03.170] - Field: 'stdout'
[21:39:03.170] - Field: 'earlySignal'
[21:39:03.171] - Field: 'lazy'
[21:39:03.171] - Field: 'state'
[21:39:03.171] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:03.171] - Launch lazy future ...
[21:39:03.172] Packages needed by the future expression (n = 0): <none>
[21:39:03.172] Packages needed by future strategies (n = 0): <none>
[21:39:03.173] {
[21:39:03.173] {
[21:39:03.173] {
[21:39:03.173] ...future.startTime <- base::Sys.time()
[21:39:03.173] {
[21:39:03.173] {
[21:39:03.173] {
[21:39:03.173] base::local({
[21:39:03.173] has_future <- base::requireNamespace("future",
[21:39:03.173] quietly = TRUE)
[21:39:03.173] if (has_future) {
[21:39:03.173] ns <- base::getNamespace("future")
[21:39:03.173] version <- ns[[".package"]][["version"]]
[21:39:03.173] if (is.null(version))
[21:39:03.173] version <- utils::packageVersion("future")
[21:39:03.173] }
[21:39:03.173] else {
[21:39:03.173] version <- NULL
[21:39:03.173] }
[21:39:03.173] if (!has_future || version < "1.8.0") {
[21:39:03.173] info <- base::c(r_version = base::gsub("R version ",
[21:39:03.173] "", base::R.version$version.string),
[21:39:03.173] platform = base::sprintf("%s (%s-bit)",
[21:39:03.173] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:03.173] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:03.173] "release", "version")], collapse = " "),
[21:39:03.173] hostname = base::Sys.info()[["nodename"]])
[21:39:03.173] info <- base::sprintf("%s: %s", base::names(info),
[21:39:03.173] info)
[21:39:03.173] info <- base::paste(info, collapse = "; ")
[21:39:03.173] if (!has_future) {
[21:39:03.173] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:03.173] info)
[21:39:03.173] }
[21:39:03.173] else {
[21:39:03.173] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:03.173] info, version)
[21:39:03.173] }
[21:39:03.173] base::stop(msg)
[21:39:03.173] }
[21:39:03.173] })
[21:39:03.173] }
[21:39:03.173] options(future.plan = NULL)
[21:39:03.173] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:03.173] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:03.173] }
[21:39:03.173] ...future.workdir <- getwd()
[21:39:03.173] }
[21:39:03.173] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:03.173] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:03.173] }
[21:39:03.173] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:03.173] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:03.173] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:03.173] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:03.173] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:03.173] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:03.173] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:03.173] base::names(...future.oldOptions))
[21:39:03.173] }
[21:39:03.173] if (FALSE) {
[21:39:03.173] }
[21:39:03.173] else {
[21:39:03.173] if (FALSE) {
[21:39:03.173] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:03.173] open = "w")
[21:39:03.173] }
[21:39:03.173] else {
[21:39:03.173] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:03.173] windows = "NUL", "/dev/null"), open = "w")
[21:39:03.173] }
[21:39:03.173] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:03.173] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:03.173] base::sink(type = "output", split = FALSE)
[21:39:03.173] base::close(...future.stdout)
[21:39:03.173] }, add = TRUE)
[21:39:03.173] }
[21:39:03.173] ...future.frame <- base::sys.nframe()
[21:39:03.173] ...future.conditions <- base::list()
[21:39:03.173] ...future.rng <- base::globalenv()$.Random.seed
[21:39:03.173] if (FALSE) {
[21:39:03.173] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:03.173] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:03.173] }
[21:39:03.173] ...future.result <- base::tryCatch({
[21:39:03.173] base::withCallingHandlers({
[21:39:03.173] ...future.value <- base::withVisible(base::local({
[21:39:03.173] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:03.173] if (!identical(...future.globals.maxSize.org,
[21:39:03.173] ...future.globals.maxSize)) {
[21:39:03.173] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:03.173] on.exit(options(oopts), add = TRUE)
[21:39:03.173] }
[21:39:03.173] {
[21:39:03.173] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:03.173] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE,
[21:39:03.173] USE.NAMES = FALSE)
[21:39:03.173] do.call(mapply, args = args)
[21:39:03.173] }
[21:39:03.173] }))
[21:39:03.173] future::FutureResult(value = ...future.value$value,
[21:39:03.173] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:03.173] ...future.rng), globalenv = if (FALSE)
[21:39:03.173] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:03.173] ...future.globalenv.names))
[21:39:03.173] else NULL, started = ...future.startTime, version = "1.8")
[21:39:03.173] }, condition = base::local({
[21:39:03.173] c <- base::c
[21:39:03.173] inherits <- base::inherits
[21:39:03.173] invokeRestart <- base::invokeRestart
[21:39:03.173] length <- base::length
[21:39:03.173] list <- base::list
[21:39:03.173] seq.int <- base::seq.int
[21:39:03.173] signalCondition <- base::signalCondition
[21:39:03.173] sys.calls <- base::sys.calls
[21:39:03.173] `[[` <- base::`[[`
[21:39:03.173] `+` <- base::`+`
[21:39:03.173] `<<-` <- base::`<<-`
[21:39:03.173] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:03.173] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:03.173] 3L)]
[21:39:03.173] }
[21:39:03.173] function(cond) {
[21:39:03.173] is_error <- inherits(cond, "error")
[21:39:03.173] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:03.173] NULL)
[21:39:03.173] if (is_error) {
[21:39:03.173] sessionInformation <- function() {
[21:39:03.173] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:03.173] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:03.173] search = base::search(), system = base::Sys.info())
[21:39:03.173] }
[21:39:03.173] ...future.conditions[[length(...future.conditions) +
[21:39:03.173] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:03.173] cond$call), session = sessionInformation(),
[21:39:03.173] timestamp = base::Sys.time(), signaled = 0L)
[21:39:03.173] signalCondition(cond)
[21:39:03.173] }
[21:39:03.173] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:03.173] "immediateCondition"))) {
[21:39:03.173] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:03.173] ...future.conditions[[length(...future.conditions) +
[21:39:03.173] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:03.173] if (TRUE && !signal) {
[21:39:03.173] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:03.173] {
[21:39:03.173] inherits <- base::inherits
[21:39:03.173] invokeRestart <- base::invokeRestart
[21:39:03.173] is.null <- base::is.null
[21:39:03.173] muffled <- FALSE
[21:39:03.173] if (inherits(cond, "message")) {
[21:39:03.173] muffled <- grepl(pattern, "muffleMessage")
[21:39:03.173] if (muffled)
[21:39:03.173] invokeRestart("muffleMessage")
[21:39:03.173] }
[21:39:03.173] else if (inherits(cond, "warning")) {
[21:39:03.173] muffled <- grepl(pattern, "muffleWarning")
[21:39:03.173] if (muffled)
[21:39:03.173] invokeRestart("muffleWarning")
[21:39:03.173] }
[21:39:03.173] else if (inherits(cond, "condition")) {
[21:39:03.173] if (!is.null(pattern)) {
[21:39:03.173] computeRestarts <- base::computeRestarts
[21:39:03.173] grepl <- base::grepl
[21:39:03.173] restarts <- computeRestarts(cond)
[21:39:03.173] for (restart in restarts) {
[21:39:03.173] name <- restart$name
[21:39:03.173] if (is.null(name))
[21:39:03.173] next
[21:39:03.173] if (!grepl(pattern, name))
[21:39:03.173] next
[21:39:03.173] invokeRestart(restart)
[21:39:03.173] muffled <- TRUE
[21:39:03.173] break
[21:39:03.173] }
[21:39:03.173] }
[21:39:03.173] }
[21:39:03.173] invisible(muffled)
[21:39:03.173] }
[21:39:03.173] muffleCondition(cond, pattern = "^muffle")
[21:39:03.173] }
[21:39:03.173] }
[21:39:03.173] else {
[21:39:03.173] if (TRUE) {
[21:39:03.173] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:03.173] {
[21:39:03.173] inherits <- base::inherits
[21:39:03.173] invokeRestart <- base::invokeRestart
[21:39:03.173] is.null <- base::is.null
[21:39:03.173] muffled <- FALSE
[21:39:03.173] if (inherits(cond, "message")) {
[21:39:03.173] muffled <- grepl(pattern, "muffleMessage")
[21:39:03.173] if (muffled)
[21:39:03.173] invokeRestart("muffleMessage")
[21:39:03.173] }
[21:39:03.173] else if (inherits(cond, "warning")) {
[21:39:03.173] muffled <- grepl(pattern, "muffleWarning")
[21:39:03.173] if (muffled)
[21:39:03.173] invokeRestart("muffleWarning")
[21:39:03.173] }
[21:39:03.173] else if (inherits(cond, "condition")) {
[21:39:03.173] if (!is.null(pattern)) {
[21:39:03.173] computeRestarts <- base::computeRestarts
[21:39:03.173] grepl <- base::grepl
[21:39:03.173] restarts <- computeRestarts(cond)
[21:39:03.173] for (restart in restarts) {
[21:39:03.173] name <- restart$name
[21:39:03.173] if (is.null(name))
[21:39:03.173] next
[21:39:03.173] if (!grepl(pattern, name))
[21:39:03.173] next
[21:39:03.173] invokeRestart(restart)
[21:39:03.173] muffled <- TRUE
[21:39:03.173] break
[21:39:03.173] }
[21:39:03.173] }
[21:39:03.173] }
[21:39:03.173] invisible(muffled)
[21:39:03.173] }
[21:39:03.173] muffleCondition(cond, pattern = "^muffle")
[21:39:03.173] }
[21:39:03.173] }
[21:39:03.173] }
[21:39:03.173] }))
[21:39:03.173] }, error = function(ex) {
[21:39:03.173] base::structure(base::list(value = NULL, visible = NULL,
[21:39:03.173] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:03.173] ...future.rng), started = ...future.startTime,
[21:39:03.173] finished = Sys.time(), session_uuid = NA_character_,
[21:39:03.173] version = "1.8"), class = "FutureResult")
[21:39:03.173] }, finally = {
[21:39:03.173] if (!identical(...future.workdir, getwd()))
[21:39:03.173] setwd(...future.workdir)
[21:39:03.173] {
[21:39:03.173] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:03.173] ...future.oldOptions$nwarnings <- NULL
[21:39:03.173] }
[21:39:03.173] base::options(...future.oldOptions)
[21:39:03.173] if (.Platform$OS.type == "windows") {
[21:39:03.173] old_names <- names(...future.oldEnvVars)
[21:39:03.173] envs <- base::Sys.getenv()
[21:39:03.173] names <- names(envs)
[21:39:03.173] common <- intersect(names, old_names)
[21:39:03.173] added <- setdiff(names, old_names)
[21:39:03.173] removed <- setdiff(old_names, names)
[21:39:03.173] changed <- common[...future.oldEnvVars[common] !=
[21:39:03.173] envs[common]]
[21:39:03.173] NAMES <- toupper(changed)
[21:39:03.173] args <- list()
[21:39:03.173] for (kk in seq_along(NAMES)) {
[21:39:03.173] name <- changed[[kk]]
[21:39:03.173] NAME <- NAMES[[kk]]
[21:39:03.173] if (name != NAME && is.element(NAME, old_names))
[21:39:03.173] next
[21:39:03.173] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:03.173] }
[21:39:03.173] NAMES <- toupper(added)
[21:39:03.173] for (kk in seq_along(NAMES)) {
[21:39:03.173] name <- added[[kk]]
[21:39:03.173] NAME <- NAMES[[kk]]
[21:39:03.173] if (name != NAME && is.element(NAME, old_names))
[21:39:03.173] next
[21:39:03.173] args[[name]] <- ""
[21:39:03.173] }
[21:39:03.173] NAMES <- toupper(removed)
[21:39:03.173] for (kk in seq_along(NAMES)) {
[21:39:03.173] name <- removed[[kk]]
[21:39:03.173] NAME <- NAMES[[kk]]
[21:39:03.173] if (name != NAME && is.element(NAME, old_names))
[21:39:03.173] next
[21:39:03.173] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:03.173] }
[21:39:03.173] if (length(args) > 0)
[21:39:03.173] base::do.call(base::Sys.setenv, args = args)
[21:39:03.173] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:03.173] }
[21:39:03.173] else {
[21:39:03.173] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:03.173] }
[21:39:03.173] {
[21:39:03.173] if (base::length(...future.futureOptionsAdded) >
[21:39:03.173] 0L) {
[21:39:03.173] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:03.173] base::names(opts) <- ...future.futureOptionsAdded
[21:39:03.173] base::options(opts)
[21:39:03.173] }
[21:39:03.173] {
[21:39:03.173] {
[21:39:03.173] NULL
[21:39:03.173] RNGkind("Mersenne-Twister")
[21:39:03.173] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:03.173] inherits = FALSE)
[21:39:03.173] }
[21:39:03.173] options(future.plan = NULL)
[21:39:03.173] if (is.na(NA_character_))
[21:39:03.173] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:03.173] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:03.173] future::plan(list(function (..., envir = parent.frame())
[21:39:03.173] {
[21:39:03.173] future <- SequentialFuture(..., envir = envir)
[21:39:03.173] if (!future$lazy)
[21:39:03.173] future <- run(future)
[21:39:03.173] invisible(future)
[21:39:03.173] }), .cleanup = FALSE, .init = FALSE)
[21:39:03.173] }
[21:39:03.173] }
[21:39:03.173] }
[21:39:03.173] })
[21:39:03.173] if (TRUE) {
[21:39:03.173] base::sink(type = "output", split = FALSE)
[21:39:03.173] if (FALSE) {
[21:39:03.173] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:03.173] }
[21:39:03.173] else {
[21:39:03.173] ...future.result["stdout"] <- base::list(NULL)
[21:39:03.173] }
[21:39:03.173] base::close(...future.stdout)
[21:39:03.173] ...future.stdout <- NULL
[21:39:03.173] }
[21:39:03.173] ...future.result$conditions <- ...future.conditions
[21:39:03.173] ...future.result$finished <- base::Sys.time()
[21:39:03.173] ...future.result
[21:39:03.173] }
[21:39:03.185] assign_globals() ...
[21:39:03.185] List of 5
[21:39:03.185] $ ...future.FUN :function (x, y)
[21:39:03.185] $ MoreArgs : NULL
[21:39:03.185] $ ...future.elements_ii :List of 2
[21:39:03.185] ..$ :List of 2
[21:39:03.185] .. ..$ : int 1
[21:39:03.185] .. ..$ : int 0
[21:39:03.185] ..$ :List of 2
[21:39:03.185] .. ..$ : int 0
[21:39:03.185] .. ..$ : int 1
[21:39:03.185] $ ...future.seeds_ii : NULL
[21:39:03.185] $ ...future.globals.maxSize: NULL
[21:39:03.185] - attr(*, "resolved")= logi FALSE
[21:39:03.185] - attr(*, "total_size")= num 6480
[21:39:03.185] - attr(*, "where")=List of 5
[21:39:03.185] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:03.185] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:03.185] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:03.185] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:03.185] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:03.185] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:03.185] - attr(*, "already-done")= logi TRUE
[21:39:03.210] - reassign environment for '...future.FUN'
[21:39:03.219] - copied '...future.FUN' to environment
[21:39:03.219] - copied 'MoreArgs' to environment
[21:39:03.219] - copied '...future.elements_ii' to environment
[21:39:03.219] - copied '...future.seeds_ii' to environment
[21:39:03.220] - copied '...future.globals.maxSize' to environment
[21:39:03.220] assign_globals() ... done
[21:39:03.220] plan(): Setting new future strategy stack:
[21:39:03.221] List of future strategies:
[21:39:03.221] 1. sequential:
[21:39:03.221] - args: function (..., envir = parent.frame())
[21:39:03.221] - tweaked: FALSE
[21:39:03.221] - call: NULL
[21:39:03.221] plan(): nbrOfWorkers() = 1
[21:39:03.723] plan(): Setting new future strategy stack:
[21:39:03.724] List of future strategies:
[21:39:03.724] 1. sequential:
[21:39:03.724] - args: function (..., envir = parent.frame())
[21:39:03.724] - tweaked: FALSE
[21:39:03.724] - call: plan(strategy)
[21:39:03.725] plan(): nbrOfWorkers() = 1
[21:39:03.725] SequentialFuture started (and completed)
[21:39:03.725] - Launch lazy future ... done
[21:39:03.726] run() for 'SequentialFuture' ... done
[21:39:03.726] Created future:
[21:39:03.726] SequentialFuture:
[21:39:03.726] Label: 'future_mapply-1'
[21:39:03.726] Expression:
[21:39:03.726] {
[21:39:03.726] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:03.726] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:03.726] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:03.726] on.exit(options(oopts), add = TRUE)
[21:39:03.726] }
[21:39:03.726] {
[21:39:03.726] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:03.726] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[21:39:03.726] do.call(mapply, args = args)
[21:39:03.726] }
[21:39:03.726] }
[21:39:03.726] Lazy evaluation: FALSE
[21:39:03.726] Asynchronous evaluation: FALSE
[21:39:03.726] Local evaluation: TRUE
[21:39:03.726] Environment: R_GlobalEnv
[21:39:03.726] Capture standard output: FALSE
[21:39:03.726] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:03.726] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:03.726] Packages: <none>
[21:39:03.726] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:03.726] Resolved: TRUE
[21:39:03.726] Value: 224 bytes of class 'list'
[21:39:03.726] Early signaling: FALSE
[21:39:03.726] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:03.726] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:03.728] Chunk #1 of 1 ... DONE
[21:39:03.729] Launching 1 futures (chunks) ... DONE
[21:39:03.729] Resolving 1 futures (chunks) ...
[21:39:03.729] resolve() on list ...
[21:39:03.729] recursive: 0
[21:39:03.730] length: 1
[21:39:03.730]
[21:39:03.730] resolved() for 'SequentialFuture' ...
[21:39:03.730] - state: 'finished'
[21:39:03.731] - run: TRUE
[21:39:03.731] - result: 'FutureResult'
[21:39:03.731] resolved() for 'SequentialFuture' ... done
[21:39:03.731] Future #1
[21:39:03.732] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:03.732] - nx: 1
[21:39:03.732] - relay: TRUE
[21:39:03.732] - stdout: TRUE
[21:39:03.733] - signal: TRUE
[21:39:03.733] - resignal: FALSE
[21:39:03.733] - force: TRUE
[21:39:03.733] - relayed: [n=1] FALSE
[21:39:03.733] - queued futures: [n=1] FALSE
[21:39:03.734] - until=1
[21:39:03.734] - relaying element #1
[21:39:03.734] - relayed: [n=1] TRUE
[21:39:03.735] - queued futures: [n=1] TRUE
[21:39:03.735] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:03.735] length: 0 (resolved future 1)
[21:39:03.735] Relaying remaining futures
[21:39:03.736] signalConditionsASAP(NULL, pos=0) ...
[21:39:03.736] - nx: 1
[21:39:03.736] - relay: TRUE
[21:39:03.736] - stdout: TRUE
[21:39:03.736] - signal: TRUE
[21:39:03.737] - resignal: FALSE
[21:39:03.737] - force: TRUE
[21:39:03.737] - relayed: [n=1] TRUE
[21:39:03.737] - queued futures: [n=1] TRUE
- flush all
[21:39:03.738] - relayed: [n=1] TRUE
[21:39:03.738] - queued futures: [n=1] TRUE
[21:39:03.738] signalConditionsASAP(NULL, pos=0) ... done
[21:39:03.738] resolve() on list ... DONE
[21:39:03.751] - Number of value chunks collected: 1
[21:39:03.751] Resolving 1 futures (chunks) ... DONE
[21:39:03.751] Reducing values from 1 chunks ...
[21:39:03.752] - Number of values collected after concatenation: 2
[21:39:03.752] - Number of values expected: 2
[21:39:03.752] Reducing values from 1 chunks ... DONE
[21:39:03.752] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ...
[21:39:03.753] future_mapply() ...
[21:39:03.753] Number of chunks: 1
[21:39:03.754] getGlobalsAndPackagesXApply() ...
[21:39:03.754] - future.globals: TRUE
[21:39:03.754] getGlobalsAndPackages() ...
[21:39:03.754] Searching for globals...
[21:39:03.758] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[21:39:03.758] Searching for globals ... DONE
[21:39:03.758] Resolving globals: FALSE
[21:39:03.759] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[21:39:03.760] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[21:39:03.760] - globals: [1] 'FUN'
[21:39:03.761]
[21:39:03.761] getGlobalsAndPackages() ... DONE
[21:39:03.761] - globals found/used: [n=1] 'FUN'
[21:39:03.761] - needed namespaces: [n=0]
[21:39:03.762] Finding globals ... DONE
[21:39:03.762] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[21:39:03.762] List of 2
[21:39:03.762] $ ...future.FUN:function (x, y)
[21:39:03.762] $ MoreArgs : NULL
[21:39:03.762] - attr(*, "where")=List of 2
[21:39:03.762] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:03.762] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:03.762] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:03.762] - attr(*, "resolved")= logi FALSE
[21:39:03.762] - attr(*, "total_size")= num NA
[21:39:03.787] Packages to be attached in all futures: [n=0]
[21:39:03.788] getGlobalsAndPackagesXApply() ... DONE
[21:39:03.788] Number of futures (= number of chunks): 1
[21:39:03.788] Launching 1 futures (chunks) ...
[21:39:03.789] Chunk #1 of 1 ...
[21:39:03.789] - Finding globals in '...' for chunk #1 ...
[21:39:03.789] getGlobalsAndPackages() ...
[21:39:03.789] Searching for globals...
[21:39:03.790]
[21:39:03.802] Searching for globals ... DONE
[21:39:03.803] - globals: [0] <none>
[21:39:03.803] getGlobalsAndPackages() ... DONE
[21:39:03.803] + additional globals found: [n=0]
[21:39:03.804] + additional namespaces needed: [n=0]
[21:39:03.804] - Finding globals in '...' for chunk #1 ... DONE
[21:39:03.804] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:03.804] - seeds: <none>
[21:39:03.805] getGlobalsAndPackages() ...
[21:39:03.805] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:03.805] Resolving globals: FALSE
[21:39:03.806] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[21:39:03.807] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[21:39:03.807] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:03.808]
[21:39:03.808] getGlobalsAndPackages() ... DONE
[21:39:03.809] run() for 'Future' ...
[21:39:03.809] - state: 'created'
[21:39:03.809] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[21:39:03.810] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:03.810] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:03.810] - Field: 'label'
[21:39:03.811] - Field: 'local'
[21:39:03.811] - Field: 'owner'
[21:39:03.811] - Field: 'envir'
[21:39:03.811] - Field: 'packages'
[21:39:03.812] - Field: 'gc'
[21:39:03.812] - Field: 'conditions'
[21:39:03.812] - Field: 'expr'
[21:39:03.812] - Field: 'uuid'
[21:39:03.813] - Field: 'seed'
[21:39:03.813] - Field: 'version'
[21:39:03.813] - Field: 'result'
[21:39:03.813] - Field: 'asynchronous'
[21:39:03.814] - Field: 'calls'
[21:39:03.814] - Field: 'globals'
[21:39:03.814] - Field: 'stdout'
[21:39:03.814] - Field: 'earlySignal'
[21:39:03.814] - Field: 'lazy'
[21:39:03.815] - Field: 'state'
[21:39:03.815] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:03.815] - Launch lazy future ...
[21:39:03.816] Packages needed by the future expression (n = 0): <none>
[21:39:03.816] Packages needed by future strategies (n = 0): <none>
[21:39:03.817] {
[21:39:03.817] {
[21:39:03.817] {
[21:39:03.817] ...future.startTime <- base::Sys.time()
[21:39:03.817] {
[21:39:03.817] {
[21:39:03.817] {
[21:39:03.817] base::local({
[21:39:03.817] has_future <- base::requireNamespace("future",
[21:39:03.817] quietly = TRUE)
[21:39:03.817] if (has_future) {
[21:39:03.817] ns <- base::getNamespace("future")
[21:39:03.817] version <- ns[[".package"]][["version"]]
[21:39:03.817] if (is.null(version))
[21:39:03.817] version <- utils::packageVersion("future")
[21:39:03.817] }
[21:39:03.817] else {
[21:39:03.817] version <- NULL
[21:39:03.817] }
[21:39:03.817] if (!has_future || version < "1.8.0") {
[21:39:03.817] info <- base::c(r_version = base::gsub("R version ",
[21:39:03.817] "", base::R.version$version.string),
[21:39:03.817] platform = base::sprintf("%s (%s-bit)",
[21:39:03.817] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:03.817] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:03.817] "release", "version")], collapse = " "),
[21:39:03.817] hostname = base::Sys.info()[["nodename"]])
[21:39:03.817] info <- base::sprintf("%s: %s", base::names(info),
[21:39:03.817] info)
[21:39:03.817] info <- base::paste(info, collapse = "; ")
[21:39:03.817] if (!has_future) {
[21:39:03.817] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:03.817] info)
[21:39:03.817] }
[21:39:03.817] else {
[21:39:03.817] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:03.817] info, version)
[21:39:03.817] }
[21:39:03.817] base::stop(msg)
[21:39:03.817] }
[21:39:03.817] })
[21:39:03.817] }
[21:39:03.817] options(future.plan = NULL)
[21:39:03.817] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:03.817] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:03.817] }
[21:39:03.817] ...future.workdir <- getwd()
[21:39:03.817] }
[21:39:03.817] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:03.817] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:03.817] }
[21:39:03.817] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:03.817] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:03.817] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:03.817] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:03.817] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:03.817] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:03.817] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:03.817] base::names(...future.oldOptions))
[21:39:03.817] }
[21:39:03.817] if (FALSE) {
[21:39:03.817] }
[21:39:03.817] else {
[21:39:03.817] if (TRUE) {
[21:39:03.817] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:03.817] open = "w")
[21:39:03.817] }
[21:39:03.817] else {
[21:39:03.817] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:03.817] windows = "NUL", "/dev/null"), open = "w")
[21:39:03.817] }
[21:39:03.817] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:03.817] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:03.817] base::sink(type = "output", split = FALSE)
[21:39:03.817] base::close(...future.stdout)
[21:39:03.817] }, add = TRUE)
[21:39:03.817] }
[21:39:03.817] ...future.frame <- base::sys.nframe()
[21:39:03.817] ...future.conditions <- base::list()
[21:39:03.817] ...future.rng <- base::globalenv()$.Random.seed
[21:39:03.817] if (FALSE) {
[21:39:03.817] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:03.817] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:03.817] }
[21:39:03.817] ...future.result <- base::tryCatch({
[21:39:03.817] base::withCallingHandlers({
[21:39:03.817] ...future.value <- base::withVisible(base::local({
[21:39:03.817] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:03.817] if (!identical(...future.globals.maxSize.org,
[21:39:03.817] ...future.globals.maxSize)) {
[21:39:03.817] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:03.817] on.exit(options(oopts), add = TRUE)
[21:39:03.817] }
[21:39:03.817] {
[21:39:03.817] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:03.817] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE,
[21:39:03.817] USE.NAMES = FALSE)
[21:39:03.817] do.call(mapply, args = args)
[21:39:03.817] }
[21:39:03.817] }))
[21:39:03.817] future::FutureResult(value = ...future.value$value,
[21:39:03.817] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:03.817] ...future.rng), globalenv = if (FALSE)
[21:39:03.817] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:03.817] ...future.globalenv.names))
[21:39:03.817] else NULL, started = ...future.startTime, version = "1.8")
[21:39:03.817] }, condition = base::local({
[21:39:03.817] c <- base::c
[21:39:03.817] inherits <- base::inherits
[21:39:03.817] invokeRestart <- base::invokeRestart
[21:39:03.817] length <- base::length
[21:39:03.817] list <- base::list
[21:39:03.817] seq.int <- base::seq.int
[21:39:03.817] signalCondition <- base::signalCondition
[21:39:03.817] sys.calls <- base::sys.calls
[21:39:03.817] `[[` <- base::`[[`
[21:39:03.817] `+` <- base::`+`
[21:39:03.817] `<<-` <- base::`<<-`
[21:39:03.817] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:03.817] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:03.817] 3L)]
[21:39:03.817] }
[21:39:03.817] function(cond) {
[21:39:03.817] is_error <- inherits(cond, "error")
[21:39:03.817] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:03.817] NULL)
[21:39:03.817] if (is_error) {
[21:39:03.817] sessionInformation <- function() {
[21:39:03.817] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:03.817] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:03.817] search = base::search(), system = base::Sys.info())
[21:39:03.817] }
[21:39:03.817] ...future.conditions[[length(...future.conditions) +
[21:39:03.817] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:03.817] cond$call), session = sessionInformation(),
[21:39:03.817] timestamp = base::Sys.time(), signaled = 0L)
[21:39:03.817] signalCondition(cond)
[21:39:03.817] }
[21:39:03.817] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:03.817] "immediateCondition"))) {
[21:39:03.817] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:03.817] ...future.conditions[[length(...future.conditions) +
[21:39:03.817] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:03.817] if (TRUE && !signal) {
[21:39:03.817] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:03.817] {
[21:39:03.817] inherits <- base::inherits
[21:39:03.817] invokeRestart <- base::invokeRestart
[21:39:03.817] is.null <- base::is.null
[21:39:03.817] muffled <- FALSE
[21:39:03.817] if (inherits(cond, "message")) {
[21:39:03.817] muffled <- grepl(pattern, "muffleMessage")
[21:39:03.817] if (muffled)
[21:39:03.817] invokeRestart("muffleMessage")
[21:39:03.817] }
[21:39:03.817] else if (inherits(cond, "warning")) {
[21:39:03.817] muffled <- grepl(pattern, "muffleWarning")
[21:39:03.817] if (muffled)
[21:39:03.817] invokeRestart("muffleWarning")
[21:39:03.817] }
[21:39:03.817] else if (inherits(cond, "condition")) {
[21:39:03.817] if (!is.null(pattern)) {
[21:39:03.817] computeRestarts <- base::computeRestarts
[21:39:03.817] grepl <- base::grepl
[21:39:03.817] restarts <- computeRestarts(cond)
[21:39:03.817] for (restart in restarts) {
[21:39:03.817] name <- restart$name
[21:39:03.817] if (is.null(name))
[21:39:03.817] next
[21:39:03.817] if (!grepl(pattern, name))
[21:39:03.817] next
[21:39:03.817] invokeRestart(restart)
[21:39:03.817] muffled <- TRUE
[21:39:03.817] break
[21:39:03.817] }
[21:39:03.817] }
[21:39:03.817] }
[21:39:03.817] invisible(muffled)
[21:39:03.817] }
[21:39:03.817] muffleCondition(cond, pattern = "^muffle")
[21:39:03.817] }
[21:39:03.817] }
[21:39:03.817] else {
[21:39:03.817] if (TRUE) {
[21:39:03.817] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:03.817] {
[21:39:03.817] inherits <- base::inherits
[21:39:03.817] invokeRestart <- base::invokeRestart
[21:39:03.817] is.null <- base::is.null
[21:39:03.817] muffled <- FALSE
[21:39:03.817] if (inherits(cond, "message")) {
[21:39:03.817] muffled <- grepl(pattern, "muffleMessage")
[21:39:03.817] if (muffled)
[21:39:03.817] invokeRestart("muffleMessage")
[21:39:03.817] }
[21:39:03.817] else if (inherits(cond, "warning")) {
[21:39:03.817] muffled <- grepl(pattern, "muffleWarning")
[21:39:03.817] if (muffled)
[21:39:03.817] invokeRestart("muffleWarning")
[21:39:03.817] }
[21:39:03.817] else if (inherits(cond, "condition")) {
[21:39:03.817] if (!is.null(pattern)) {
[21:39:03.817] computeRestarts <- base::computeRestarts
[21:39:03.817] grepl <- base::grepl
[21:39:03.817] restarts <- computeRestarts(cond)
[21:39:03.817] for (restart in restarts) {
[21:39:03.817] name <- restart$name
[21:39:03.817] if (is.null(name))
[21:39:03.817] next
[21:39:03.817] if (!grepl(pattern, name))
[21:39:03.817] next
[21:39:03.817] invokeRestart(restart)
[21:39:03.817] muffled <- TRUE
[21:39:03.817] break
[21:39:03.817] }
[21:39:03.817] }
[21:39:03.817] }
[21:39:03.817] invisible(muffled)
[21:39:03.817] }
[21:39:03.817] muffleCondition(cond, pattern = "^muffle")
[21:39:03.817] }
[21:39:03.817] }
[21:39:03.817] }
[21:39:03.817] }))
[21:39:03.817] }, error = function(ex) {
[21:39:03.817] base::structure(base::list(value = NULL, visible = NULL,
[21:39:03.817] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:03.817] ...future.rng), started = ...future.startTime,
[21:39:03.817] finished = Sys.time(), session_uuid = NA_character_,
[21:39:03.817] version = "1.8"), class = "FutureResult")
[21:39:03.817] }, finally = {
[21:39:03.817] if (!identical(...future.workdir, getwd()))
[21:39:03.817] setwd(...future.workdir)
[21:39:03.817] {
[21:39:03.817] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:03.817] ...future.oldOptions$nwarnings <- NULL
[21:39:03.817] }
[21:39:03.817] base::options(...future.oldOptions)
[21:39:03.817] if (.Platform$OS.type == "windows") {
[21:39:03.817] old_names <- names(...future.oldEnvVars)
[21:39:03.817] envs <- base::Sys.getenv()
[21:39:03.817] names <- names(envs)
[21:39:03.817] common <- intersect(names, old_names)
[21:39:03.817] added <- setdiff(names, old_names)
[21:39:03.817] removed <- setdiff(old_names, names)
[21:39:03.817] changed <- common[...future.oldEnvVars[common] !=
[21:39:03.817] envs[common]]
[21:39:03.817] NAMES <- toupper(changed)
[21:39:03.817] args <- list()
[21:39:03.817] for (kk in seq_along(NAMES)) {
[21:39:03.817] name <- changed[[kk]]
[21:39:03.817] NAME <- NAMES[[kk]]
[21:39:03.817] if (name != NAME && is.element(NAME, old_names))
[21:39:03.817] next
[21:39:03.817] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:03.817] }
[21:39:03.817] NAMES <- toupper(added)
[21:39:03.817] for (kk in seq_along(NAMES)) {
[21:39:03.817] name <- added[[kk]]
[21:39:03.817] NAME <- NAMES[[kk]]
[21:39:03.817] if (name != NAME && is.element(NAME, old_names))
[21:39:03.817] next
[21:39:03.817] args[[name]] <- ""
[21:39:03.817] }
[21:39:03.817] NAMES <- toupper(removed)
[21:39:03.817] for (kk in seq_along(NAMES)) {
[21:39:03.817] name <- removed[[kk]]
[21:39:03.817] NAME <- NAMES[[kk]]
[21:39:03.817] if (name != NAME && is.element(NAME, old_names))
[21:39:03.817] next
[21:39:03.817] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:03.817] }
[21:39:03.817] if (length(args) > 0)
[21:39:03.817] base::do.call(base::Sys.setenv, args = args)
[21:39:03.817] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:03.817] }
[21:39:03.817] else {
[21:39:03.817] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:03.817] }
[21:39:03.817] {
[21:39:03.817] if (base::length(...future.futureOptionsAdded) >
[21:39:03.817] 0L) {
[21:39:03.817] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:03.817] base::names(opts) <- ...future.futureOptionsAdded
[21:39:03.817] base::options(opts)
[21:39:03.817] }
[21:39:03.817] {
[21:39:03.817] {
[21:39:03.817] NULL
[21:39:03.817] RNGkind("Mersenne-Twister")
[21:39:03.817] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:03.817] inherits = FALSE)
[21:39:03.817] }
[21:39:03.817] options(future.plan = NULL)
[21:39:03.817] if (is.na(NA_character_))
[21:39:03.817] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:03.817] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:03.817] future::plan(list(function (..., envir = parent.frame())
[21:39:03.817] {
[21:39:03.817] future <- SequentialFuture(..., envir = envir)
[21:39:03.817] if (!future$lazy)
[21:39:03.817] future <- run(future)
[21:39:03.817] invisible(future)
[21:39:03.817] }), .cleanup = FALSE, .init = FALSE)
[21:39:03.817] }
[21:39:03.817] }
[21:39:03.817] }
[21:39:03.817] })
[21:39:03.817] if (TRUE) {
[21:39:03.817] base::sink(type = "output", split = FALSE)
[21:39:03.817] if (TRUE) {
[21:39:03.817] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:03.817] }
[21:39:03.817] else {
[21:39:03.817] ...future.result["stdout"] <- base::list(NULL)
[21:39:03.817] }
[21:39:03.817] base::close(...future.stdout)
[21:39:03.817] ...future.stdout <- NULL
[21:39:03.817] }
[21:39:03.817] ...future.result$conditions <- ...future.conditions
[21:39:03.817] ...future.result$finished <- base::Sys.time()
[21:39:03.817] ...future.result
[21:39:03.817] }
[21:39:03.820] assign_globals() ...
[21:39:03.821] List of 5
[21:39:03.821] $ ...future.FUN :function (x, y)
[21:39:03.821] $ MoreArgs : NULL
[21:39:03.821] $ ...future.elements_ii :List of 2
[21:39:03.821] ..$ :List of 2
[21:39:03.821] .. ..$ : int 1
[21:39:03.821] .. ..$ : int 0
[21:39:03.821] ..$ :List of 2
[21:39:03.821] .. ..$ : int 0
[21:39:03.821] .. ..$ : int 1
[21:39:03.821] $ ...future.seeds_ii : NULL
[21:39:03.821] $ ...future.globals.maxSize: NULL
[21:39:03.821] - attr(*, "resolved")= logi FALSE
[21:39:03.821] - attr(*, "total_size")= num 6480
[21:39:03.821] - attr(*, "where")=List of 5
[21:39:03.821] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:03.821] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:03.821] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:03.821] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:03.821] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:03.821] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:03.821] - attr(*, "already-done")= logi TRUE
[21:39:03.851] - reassign environment for '...future.FUN'
[21:39:03.851] - copied '...future.FUN' to environment
[21:39:03.851] - copied 'MoreArgs' to environment
[21:39:03.852] - copied '...future.elements_ii' to environment
[21:39:03.852] - copied '...future.seeds_ii' to environment
[21:39:03.852] - copied '...future.globals.maxSize' to environment
[21:39:03.852] assign_globals() ... done
[21:39:03.853] plan(): Setting new future strategy stack:
[21:39:03.853] List of future strategies:
[21:39:03.853] 1. sequential:
[21:39:03.853] - args: function (..., envir = parent.frame())
[21:39:03.853] - tweaked: FALSE
[21:39:03.853] - call: NULL
[21:39:03.854] plan(): nbrOfWorkers() = 1
[21:39:04.373] plan(): Setting new future strategy stack:
[21:39:04.373] List of future strategies:
[21:39:04.373] 1. sequential:
[21:39:04.373] - args: function (..., envir = parent.frame())
[21:39:04.373] - tweaked: FALSE
[21:39:04.373] - call: plan(strategy)
[21:39:04.374] plan(): nbrOfWorkers() = 1
[21:39:04.374] SequentialFuture started (and completed)
[21:39:04.375] - Launch lazy future ... done
[21:39:04.375] run() for 'SequentialFuture' ... done
[21:39:04.375] Created future:
[21:39:04.375] SequentialFuture:
[21:39:04.375] Label: 'future_mapply-1'
[21:39:04.375] Expression:
[21:39:04.375] {
[21:39:04.375] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:04.375] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:04.375] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:04.375] on.exit(options(oopts), add = TRUE)
[21:39:04.375] }
[21:39:04.375] {
[21:39:04.375] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:04.375] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[21:39:04.375] do.call(mapply, args = args)
[21:39:04.375] }
[21:39:04.375] }
[21:39:04.375] Lazy evaluation: FALSE
[21:39:04.375] Asynchronous evaluation: FALSE
[21:39:04.375] Local evaluation: TRUE
[21:39:04.375] Environment: R_GlobalEnv
[21:39:04.375] Capture standard output: TRUE
[21:39:04.375] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:04.375] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:04.375] Packages: <none>
[21:39:04.375] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:04.375] Resolved: TRUE
[21:39:04.375] Value: 224 bytes of class 'list'
[21:39:04.375] Early signaling: FALSE
[21:39:04.375] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:04.375] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:04.377] Chunk #1 of 1 ... DONE
[21:39:04.378] Launching 1 futures (chunks) ... DONE
[21:39:04.378] Resolving 1 futures (chunks) ...
[21:39:04.378] resolve() on list ...
[21:39:04.378] recursive: 0
[21:39:04.379] length: 1
[21:39:04.379]
[21:39:04.379] resolved() for 'SequentialFuture' ...
[21:39:04.379] - state: 'finished'
[21:39:04.380] - run: TRUE
[21:39:04.380] - result: 'FutureResult'
[21:39:04.380] resolved() for 'SequentialFuture' ... done
[21:39:04.380] Future #1
[21:39:04.381] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:04.381] - nx: 1
[21:39:04.381] - relay: TRUE
[21:39:04.381] - stdout: TRUE
[21:39:04.385] - signal: TRUE
[21:39:04.385] - resignal: FALSE
[21:39:04.385] - force: TRUE
[21:39:04.385] - relayed: [n=1] FALSE
[21:39:04.386] - queued futures: [n=1] FALSE
[21:39:04.386] - until=1
[21:39:04.386] - relaying element #1
[21:39:04.399] - relayed: [n=1] TRUE
[21:39:04.399] - queued futures: [n=1] TRUE
[21:39:04.399] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:04.399] length: 0 (resolved future 1)
[21:39:04.400] Relaying remaining futures
[21:39:04.400] signalConditionsASAP(NULL, pos=0) ...
[21:39:04.400] - nx: 1
[21:39:04.400] - relay: TRUE
[21:39:04.401] - stdout: TRUE
[21:39:04.401] - signal: TRUE
[21:39:04.401] - resignal: FALSE
[21:39:04.401] - force: TRUE
[21:39:04.401] - relayed: [n=1] TRUE
[21:39:04.402] - queued futures: [n=1] TRUE
- flush all
[21:39:04.402] - relayed: [n=1] TRUE
[21:39:04.402] - queued futures: [n=1] TRUE
[21:39:04.402] signalConditionsASAP(NULL, pos=0) ... done
[21:39:04.403] resolve() on list ... DONE
[21:39:04.403] - Number of value chunks collected: 1
[21:39:04.403] Resolving 1 futures (chunks) ... DONE
[21:39:04.404] Reducing values from 1 chunks ...
[21:39:04.404] - Number of values collected after concatenation: 2
[21:39:04.404] - Number of values expected: 2
[21:39:04.404] Reducing values from 1 chunks ... DONE
[21:39:04.404] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ... DONE
* future_mapply(x, ..., future.stdout = NA) ...
[21:39:04.405] future_mapply() ...
[21:39:04.406] Number of chunks: 1
[21:39:04.406] getGlobalsAndPackagesXApply() ...
[21:39:04.406] - future.globals: TRUE
[21:39:04.406] getGlobalsAndPackages() ...
[21:39:04.407] Searching for globals...
[21:39:04.410] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[21:39:04.427] Searching for globals ... DONE
[21:39:04.427] Resolving globals: FALSE
[21:39:04.428] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[21:39:04.429] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[21:39:04.429] - globals: [1] 'FUN'
[21:39:04.429]
[21:39:04.430] getGlobalsAndPackages() ... DONE
[21:39:04.430] - globals found/used: [n=1] 'FUN'
[21:39:04.430] - needed namespaces: [n=0]
[21:39:04.430] Finding globals ... DONE
[21:39:04.431] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[21:39:04.431] List of 2
[21:39:04.431] $ ...future.FUN:function (x, y)
[21:39:04.431] $ MoreArgs : NULL
[21:39:04.431] - attr(*, "where")=List of 2
[21:39:04.431] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:04.431] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:04.431] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:04.431] - attr(*, "resolved")= logi FALSE
[21:39:04.431] - attr(*, "total_size")= num NA
[21:39:04.437] Packages to be attached in all futures: [n=0]
[21:39:04.437] getGlobalsAndPackagesXApply() ... DONE
[21:39:04.437] Number of futures (= number of chunks): 1
[21:39:04.438] Launching 1 futures (chunks) ...
[21:39:04.438] Chunk #1 of 1 ...
[21:39:04.438] - Finding globals in '...' for chunk #1 ...
[21:39:04.438] getGlobalsAndPackages() ...
[21:39:04.439] Searching for globals...
[21:39:04.439]
[21:39:04.440] Searching for globals ... DONE
[21:39:04.440] - globals: [0] <none>
[21:39:04.440] getGlobalsAndPackages() ... DONE
[21:39:04.440] + additional globals found: [n=0]
[21:39:04.440] + additional namespaces needed: [n=0]
[21:39:04.441] - Finding globals in '...' for chunk #1 ... DONE
[21:39:04.441] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:04.441] - seeds: <none>
[21:39:04.441] getGlobalsAndPackages() ...
[21:39:04.442] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:04.442] Resolving globals: FALSE
[21:39:04.459] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[21:39:04.460] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[21:39:04.460] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:04.461]
[21:39:04.461] getGlobalsAndPackages() ... DONE
[21:39:04.462] run() for 'Future' ...
[21:39:04.462] - state: 'created'
[21:39:04.462] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[21:39:04.464] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:04.464] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:04.464] - Field: 'label'
[21:39:04.464] - Field: 'local'
[21:39:04.465] - Field: 'owner'
[21:39:04.465] - Field: 'envir'
[21:39:04.465] - Field: 'packages'
[21:39:04.465] - Field: 'gc'
[21:39:04.466] - Field: 'conditions'
[21:39:04.466] - Field: 'expr'
[21:39:04.466] - Field: 'uuid'
[21:39:04.466] - Field: 'seed'
[21:39:04.466] - Field: 'version'
[21:39:04.467] - Field: 'result'
[21:39:04.467] - Field: 'asynchronous'
[21:39:04.467] - Field: 'calls'
[21:39:04.467] - Field: 'globals'
[21:39:04.468] - Field: 'stdout'
[21:39:04.468] - Field: 'earlySignal'
[21:39:04.468] - Field: 'lazy'
[21:39:04.468] - Field: 'state'
[21:39:04.469] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:04.469] - Launch lazy future ...
[21:39:04.469] Packages needed by the future expression (n = 0): <none>
[21:39:04.469] Packages needed by future strategies (n = 0): <none>
[21:39:04.471] {
[21:39:04.471] {
[21:39:04.471] {
[21:39:04.471] ...future.startTime <- base::Sys.time()
[21:39:04.471] {
[21:39:04.471] {
[21:39:04.471] {
[21:39:04.471] base::local({
[21:39:04.471] has_future <- base::requireNamespace("future",
[21:39:04.471] quietly = TRUE)
[21:39:04.471] if (has_future) {
[21:39:04.471] ns <- base::getNamespace("future")
[21:39:04.471] version <- ns[[".package"]][["version"]]
[21:39:04.471] if (is.null(version))
[21:39:04.471] version <- utils::packageVersion("future")
[21:39:04.471] }
[21:39:04.471] else {
[21:39:04.471] version <- NULL
[21:39:04.471] }
[21:39:04.471] if (!has_future || version < "1.8.0") {
[21:39:04.471] info <- base::c(r_version = base::gsub("R version ",
[21:39:04.471] "", base::R.version$version.string),
[21:39:04.471] platform = base::sprintf("%s (%s-bit)",
[21:39:04.471] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:04.471] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:04.471] "release", "version")], collapse = " "),
[21:39:04.471] hostname = base::Sys.info()[["nodename"]])
[21:39:04.471] info <- base::sprintf("%s: %s", base::names(info),
[21:39:04.471] info)
[21:39:04.471] info <- base::paste(info, collapse = "; ")
[21:39:04.471] if (!has_future) {
[21:39:04.471] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:04.471] info)
[21:39:04.471] }
[21:39:04.471] else {
[21:39:04.471] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:04.471] info, version)
[21:39:04.471] }
[21:39:04.471] base::stop(msg)
[21:39:04.471] }
[21:39:04.471] })
[21:39:04.471] }
[21:39:04.471] options(future.plan = NULL)
[21:39:04.471] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:04.471] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:04.471] }
[21:39:04.471] ...future.workdir <- getwd()
[21:39:04.471] }
[21:39:04.471] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:04.471] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:04.471] }
[21:39:04.471] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:04.471] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:04.471] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:04.471] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:04.471] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:04.471] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:04.471] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:04.471] base::names(...future.oldOptions))
[21:39:04.471] }
[21:39:04.471] if (TRUE) {
[21:39:04.471] }
[21:39:04.471] else {
[21:39:04.471] if (NA) {
[21:39:04.471] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:04.471] open = "w")
[21:39:04.471] }
[21:39:04.471] else {
[21:39:04.471] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:04.471] windows = "NUL", "/dev/null"), open = "w")
[21:39:04.471] }
[21:39:04.471] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:04.471] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:04.471] base::sink(type = "output", split = FALSE)
[21:39:04.471] base::close(...future.stdout)
[21:39:04.471] }, add = TRUE)
[21:39:04.471] }
[21:39:04.471] ...future.frame <- base::sys.nframe()
[21:39:04.471] ...future.conditions <- base::list()
[21:39:04.471] ...future.rng <- base::globalenv()$.Random.seed
[21:39:04.471] if (FALSE) {
[21:39:04.471] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:04.471] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:04.471] }
[21:39:04.471] ...future.result <- base::tryCatch({
[21:39:04.471] base::withCallingHandlers({
[21:39:04.471] ...future.value <- base::withVisible(base::local({
[21:39:04.471] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:04.471] if (!identical(...future.globals.maxSize.org,
[21:39:04.471] ...future.globals.maxSize)) {
[21:39:04.471] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:04.471] on.exit(options(oopts), add = TRUE)
[21:39:04.471] }
[21:39:04.471] {
[21:39:04.471] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:04.471] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE,
[21:39:04.471] USE.NAMES = FALSE)
[21:39:04.471] do.call(mapply, args = args)
[21:39:04.471] }
[21:39:04.471] }))
[21:39:04.471] future::FutureResult(value = ...future.value$value,
[21:39:04.471] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:04.471] ...future.rng), globalenv = if (FALSE)
[21:39:04.471] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:04.471] ...future.globalenv.names))
[21:39:04.471] else NULL, started = ...future.startTime, version = "1.8")
[21:39:04.471] }, condition = base::local({
[21:39:04.471] c <- base::c
[21:39:04.471] inherits <- base::inherits
[21:39:04.471] invokeRestart <- base::invokeRestart
[21:39:04.471] length <- base::length
[21:39:04.471] list <- base::list
[21:39:04.471] seq.int <- base::seq.int
[21:39:04.471] signalCondition <- base::signalCondition
[21:39:04.471] sys.calls <- base::sys.calls
[21:39:04.471] `[[` <- base::`[[`
[21:39:04.471] `+` <- base::`+`
[21:39:04.471] `<<-` <- base::`<<-`
[21:39:04.471] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:04.471] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:04.471] 3L)]
[21:39:04.471] }
[21:39:04.471] function(cond) {
[21:39:04.471] is_error <- inherits(cond, "error")
[21:39:04.471] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:04.471] NULL)
[21:39:04.471] if (is_error) {
[21:39:04.471] sessionInformation <- function() {
[21:39:04.471] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:04.471] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:04.471] search = base::search(), system = base::Sys.info())
[21:39:04.471] }
[21:39:04.471] ...future.conditions[[length(...future.conditions) +
[21:39:04.471] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:04.471] cond$call), session = sessionInformation(),
[21:39:04.471] timestamp = base::Sys.time(), signaled = 0L)
[21:39:04.471] signalCondition(cond)
[21:39:04.471] }
[21:39:04.471] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:04.471] "immediateCondition"))) {
[21:39:04.471] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:04.471] ...future.conditions[[length(...future.conditions) +
[21:39:04.471] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:04.471] if (TRUE && !signal) {
[21:39:04.471] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:04.471] {
[21:39:04.471] inherits <- base::inherits
[21:39:04.471] invokeRestart <- base::invokeRestart
[21:39:04.471] is.null <- base::is.null
[21:39:04.471] muffled <- FALSE
[21:39:04.471] if (inherits(cond, "message")) {
[21:39:04.471] muffled <- grepl(pattern, "muffleMessage")
[21:39:04.471] if (muffled)
[21:39:04.471] invokeRestart("muffleMessage")
[21:39:04.471] }
[21:39:04.471] else if (inherits(cond, "warning")) {
[21:39:04.471] muffled <- grepl(pattern, "muffleWarning")
[21:39:04.471] if (muffled)
[21:39:04.471] invokeRestart("muffleWarning")
[21:39:04.471] }
[21:39:04.471] else if (inherits(cond, "condition")) {
[21:39:04.471] if (!is.null(pattern)) {
[21:39:04.471] computeRestarts <- base::computeRestarts
[21:39:04.471] grepl <- base::grepl
[21:39:04.471] restarts <- computeRestarts(cond)
[21:39:04.471] for (restart in restarts) {
[21:39:04.471] name <- restart$name
[21:39:04.471] if (is.null(name))
[21:39:04.471] next
[21:39:04.471] if (!grepl(pattern, name))
[21:39:04.471] next
[21:39:04.471] invokeRestart(restart)
[21:39:04.471] muffled <- TRUE
[21:39:04.471] break
[21:39:04.471] }
[21:39:04.471] }
[21:39:04.471] }
[21:39:04.471] invisible(muffled)
[21:39:04.471] }
[21:39:04.471] muffleCondition(cond, pattern = "^muffle")
[21:39:04.471] }
[21:39:04.471] }
[21:39:04.471] else {
[21:39:04.471] if (TRUE) {
[21:39:04.471] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:04.471] {
[21:39:04.471] inherits <- base::inherits
[21:39:04.471] invokeRestart <- base::invokeRestart
[21:39:04.471] is.null <- base::is.null
[21:39:04.471] muffled <- FALSE
[21:39:04.471] if (inherits(cond, "message")) {
[21:39:04.471] muffled <- grepl(pattern, "muffleMessage")
[21:39:04.471] if (muffled)
[21:39:04.471] invokeRestart("muffleMessage")
[21:39:04.471] }
[21:39:04.471] else if (inherits(cond, "warning")) {
[21:39:04.471] muffled <- grepl(pattern, "muffleWarning")
[21:39:04.471] if (muffled)
[21:39:04.471] invokeRestart("muffleWarning")
[21:39:04.471] }
[21:39:04.471] else if (inherits(cond, "condition")) {
[21:39:04.471] if (!is.null(pattern)) {
[21:39:04.471] computeRestarts <- base::computeRestarts
[21:39:04.471] grepl <- base::grepl
[21:39:04.471] restarts <- computeRestarts(cond)
[21:39:04.471] for (restart in restarts) {
[21:39:04.471] name <- restart$name
[21:39:04.471] if (is.null(name))
[21:39:04.471] next
[21:39:04.471] if (!grepl(pattern, name))
[21:39:04.471] next
[21:39:04.471] invokeRestart(restart)
[21:39:04.471] muffled <- TRUE
[21:39:04.471] break
[21:39:04.471] }
[21:39:04.471] }
[21:39:04.471] }
[21:39:04.471] invisible(muffled)
[21:39:04.471] }
[21:39:04.471] muffleCondition(cond, pattern = "^muffle")
[21:39:04.471] }
[21:39:04.471] }
[21:39:04.471] }
[21:39:04.471] }))
[21:39:04.471] }, error = function(ex) {
[21:39:04.471] base::structure(base::list(value = NULL, visible = NULL,
[21:39:04.471] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:04.471] ...future.rng), started = ...future.startTime,
[21:39:04.471] finished = Sys.time(), session_uuid = NA_character_,
[21:39:04.471] version = "1.8"), class = "FutureResult")
[21:39:04.471] }, finally = {
[21:39:04.471] if (!identical(...future.workdir, getwd()))
[21:39:04.471] setwd(...future.workdir)
[21:39:04.471] {
[21:39:04.471] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:04.471] ...future.oldOptions$nwarnings <- NULL
[21:39:04.471] }
[21:39:04.471] base::options(...future.oldOptions)
[21:39:04.471] if (.Platform$OS.type == "windows") {
[21:39:04.471] old_names <- names(...future.oldEnvVars)
[21:39:04.471] envs <- base::Sys.getenv()
[21:39:04.471] names <- names(envs)
[21:39:04.471] common <- intersect(names, old_names)
[21:39:04.471] added <- setdiff(names, old_names)
[21:39:04.471] removed <- setdiff(old_names, names)
[21:39:04.471] changed <- common[...future.oldEnvVars[common] !=
[21:39:04.471] envs[common]]
[21:39:04.471] NAMES <- toupper(changed)
[21:39:04.471] args <- list()
[21:39:04.471] for (kk in seq_along(NAMES)) {
[21:39:04.471] name <- changed[[kk]]
[21:39:04.471] NAME <- NAMES[[kk]]
[21:39:04.471] if (name != NAME && is.element(NAME, old_names))
[21:39:04.471] next
[21:39:04.471] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:04.471] }
[21:39:04.471] NAMES <- toupper(added)
[21:39:04.471] for (kk in seq_along(NAMES)) {
[21:39:04.471] name <- added[[kk]]
[21:39:04.471] NAME <- NAMES[[kk]]
[21:39:04.471] if (name != NAME && is.element(NAME, old_names))
[21:39:04.471] next
[21:39:04.471] args[[name]] <- ""
[21:39:04.471] }
[21:39:04.471] NAMES <- toupper(removed)
[21:39:04.471] for (kk in seq_along(NAMES)) {
[21:39:04.471] name <- removed[[kk]]
[21:39:04.471] NAME <- NAMES[[kk]]
[21:39:04.471] if (name != NAME && is.element(NAME, old_names))
[21:39:04.471] next
[21:39:04.471] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:04.471] }
[21:39:04.471] if (length(args) > 0)
[21:39:04.471] base::do.call(base::Sys.setenv, args = args)
[21:39:04.471] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:04.471] }
[21:39:04.471] else {
[21:39:04.471] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:04.471] }
[21:39:04.471] {
[21:39:04.471] if (base::length(...future.futureOptionsAdded) >
[21:39:04.471] 0L) {
[21:39:04.471] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:04.471] base::names(opts) <- ...future.futureOptionsAdded
[21:39:04.471] base::options(opts)
[21:39:04.471] }
[21:39:04.471] {
[21:39:04.471] {
[21:39:04.471] NULL
[21:39:04.471] RNGkind("Mersenne-Twister")
[21:39:04.471] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:04.471] inherits = FALSE)
[21:39:04.471] }
[21:39:04.471] options(future.plan = NULL)
[21:39:04.471] if (is.na(NA_character_))
[21:39:04.471] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:04.471] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:04.471] future::plan(list(function (..., envir = parent.frame())
[21:39:04.471] {
[21:39:04.471] future <- SequentialFuture(..., envir = envir)
[21:39:04.471] if (!future$lazy)
[21:39:04.471] future <- run(future)
[21:39:04.471] invisible(future)
[21:39:04.471] }), .cleanup = FALSE, .init = FALSE)
[21:39:04.471] }
[21:39:04.471] }
[21:39:04.471] }
[21:39:04.471] })
[21:39:04.471] if (FALSE) {
[21:39:04.471] base::sink(type = "output", split = FALSE)
[21:39:04.471] if (NA) {
[21:39:04.471] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:04.471] }
[21:39:04.471] else {
[21:39:04.471] ...future.result["stdout"] <- base::list(NULL)
[21:39:04.471] }
[21:39:04.471] base::close(...future.stdout)
[21:39:04.471] ...future.stdout <- NULL
[21:39:04.471] }
[21:39:04.471] ...future.result$conditions <- ...future.conditions
[21:39:04.471] ...future.result$finished <- base::Sys.time()
[21:39:04.471] ...future.result
[21:39:04.471] }
[21:39:04.474] assign_globals() ...
[21:39:04.474] List of 5
[21:39:04.474] $ ...future.FUN :function (x, y)
[21:39:04.474] $ MoreArgs : NULL
[21:39:04.474] $ ...future.elements_ii :List of 2
[21:39:04.474] ..$ :List of 2
[21:39:04.474] .. ..$ : int 1
[21:39:04.474] .. ..$ : int 0
[21:39:04.474] ..$ :List of 2
[21:39:04.474] .. ..$ : int 0
[21:39:04.474] .. ..$ : int 1
[21:39:04.474] $ ...future.seeds_ii : NULL
[21:39:04.474] $ ...future.globals.maxSize: NULL
[21:39:04.474] - attr(*, "resolved")= logi FALSE
[21:39:04.474] - attr(*, "total_size")= num 6480
[21:39:04.474] - attr(*, "where")=List of 5
[21:39:04.474] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:04.474] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:04.474] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:04.474] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:04.474] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:04.474] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:04.474] - attr(*, "already-done")= logi TRUE
[21:39:04.510] - reassign environment for '...future.FUN'
[21:39:04.510] - copied '...future.FUN' to environment
[21:39:04.511] - copied 'MoreArgs' to environment
[21:39:04.511] - copied '...future.elements_ii' to environment
[21:39:04.511] - copied '...future.seeds_ii' to environment
[21:39:04.511] - copied '...future.globals.maxSize' to environment
[21:39:04.512] assign_globals() ... done
[21:39:04.512] plan(): Setting new future strategy stack:
[21:39:04.512] List of future strategies:
[21:39:04.512] 1. sequential:
[21:39:04.512] - args: function (..., envir = parent.frame())
[21:39:04.512] - tweaked: FALSE
[21:39:04.512] - call: NULL
[21:39:04.513] plan(): nbrOfWorkers() = 1
[21:39:05.015] plan(): Setting new future strategy stack:
[21:39:05.016] List of future strategies:
[21:39:05.016] 1. sequential:
[21:39:05.016] - args: function (..., envir = parent.frame())
[21:39:05.016] - tweaked: FALSE
[21:39:05.016] - call: plan(strategy)
[21:39:05.017] plan(): nbrOfWorkers() = 1
[21:39:05.017] SequentialFuture started (and completed)
[21:39:05.017] - Launch lazy future ... done
[21:39:05.017] run() for 'SequentialFuture' ... done
[21:39:05.018] Created future:
[21:39:05.018] SequentialFuture:
[21:39:05.018] Label: 'future_mapply-1'
[21:39:05.018] Expression:
[21:39:05.018] {
[21:39:05.018] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:05.018] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:05.018] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:05.018] on.exit(options(oopts), add = TRUE)
[21:39:05.018] }
[21:39:05.018] {
[21:39:05.018] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:05.018] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[21:39:05.018] do.call(mapply, args = args)
[21:39:05.018] }
[21:39:05.018] }
[21:39:05.018] Lazy evaluation: FALSE
[21:39:05.018] Asynchronous evaluation: FALSE
[21:39:05.018] Local evaluation: TRUE
[21:39:05.018] Environment: R_GlobalEnv
[21:39:05.018] Capture standard output: NA
[21:39:05.018] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:05.018] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:05.018] Packages: <none>
[21:39:05.018] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:05.018] Resolved: TRUE
[21:39:05.018] Value: 224 bytes of class 'list'
[21:39:05.018] Early signaling: FALSE
[21:39:05.018] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:05.018] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:05.020] Chunk #1 of 1 ... DONE
[21:39:05.020] Launching 1 futures (chunks) ... DONE
[21:39:05.021] Resolving 1 futures (chunks) ...
[21:39:05.021] resolve() on list ...
[21:39:05.021] recursive: 0
[21:39:05.021] length: 1
[21:39:05.021]
[21:39:05.022] resolved() for 'SequentialFuture' ...
[21:39:05.022] - state: 'finished'
[21:39:05.022] - run: TRUE
[21:39:05.022] - result: 'FutureResult'
[21:39:05.023] resolved() for 'SequentialFuture' ... done
[21:39:05.023] Future #1
[21:39:05.023] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:05.023] - nx: 1
[21:39:05.024] - relay: TRUE
[21:39:05.024] - stdout: TRUE
[21:39:05.024] - signal: TRUE
[21:39:05.024] - resignal: FALSE
[21:39:05.025] - force: TRUE
[21:39:05.025] - relayed: [n=1] FALSE
[21:39:05.025] - queued futures: [n=1] FALSE
[21:39:05.025] - until=1
[21:39:05.025] - relaying element #1
[21:39:05.026] - relayed: [n=1] TRUE
[21:39:05.026] - queued futures: [n=1] TRUE
[21:39:05.026] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:05.027] length: 0 (resolved future 1)
[21:39:05.027] Relaying remaining futures
[21:39:05.027] signalConditionsASAP(NULL, pos=0) ...
[21:39:05.027] - nx: 1
[21:39:05.027] - relay: TRUE
[21:39:05.028] - stdout: TRUE
[21:39:05.028] - signal: TRUE
[21:39:05.028] - resignal: FALSE
[21:39:05.028] - force: TRUE
[21:39:05.028] - relayed: [n=1] TRUE
[21:39:05.029] - queued futures: [n=1] TRUE
- flush all
[21:39:05.029] - relayed: [n=1] TRUE
[21:39:05.029] - queued futures: [n=1] TRUE
[21:39:05.029] signalConditionsASAP(NULL, pos=0) ... done
[21:39:05.030] resolve() on list ... DONE
[21:39:05.030] - Number of value chunks collected: 1
[21:39:05.030] Resolving 1 futures (chunks) ... DONE
[21:39:05.047] Reducing values from 1 chunks ...
[21:39:05.047] - Number of values collected after concatenation: 2
[21:39:05.047] - Number of values expected: 2
[21:39:05.047] Reducing values from 1 chunks ... DONE
[21:39:05.048] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = NA) ... DONE
* plan('sequential') ... DONE
* plan('multicore') ...
[21:39:05.049] plan(): Setting new future strategy stack:
[21:39:05.049] List of future strategies:
[21:39:05.049] 1. multicore:
[21:39:05.049] - args: function (..., workers = availableCores(constraints = "multicore"), envir = parent.frame())
[21:39:05.049] - tweaked: FALSE
[21:39:05.049] - call: plan(strategy)
[21:39:05.099] plan(): nbrOfWorkers() = 1
* future_lapply(x, ..., future.stdout = FALSE) ...
[21:39:05.100] future_lapply() ...
[21:39:05.154] Number of chunks: 1
[21:39:05.154] getGlobalsAndPackagesXApply() ...
[21:39:05.154] - future.globals: TRUE
[21:39:05.155] getGlobalsAndPackages() ...
[21:39:05.155] Searching for globals...
[21:39:05.158] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[21:39:05.159] Searching for globals ... DONE
[21:39:05.159] Resolving globals: FALSE
[21:39:05.160] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[21:39:05.161] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[21:39:05.161] - globals: [1] 'FUN'
[21:39:05.161]
[21:39:05.161] getGlobalsAndPackages() ... DONE
[21:39:05.162] - globals found/used: [n=1] 'FUN'
[21:39:05.162] - needed namespaces: [n=0]
[21:39:05.162] Finding globals ... DONE
[21:39:05.162] - use_args: TRUE
[21:39:05.163] - Getting '...' globals ...
[21:39:05.163] resolve() on list ...
[21:39:05.164] recursive: 0
[21:39:05.164] length: 1
[21:39:05.164] elements: '...'
[21:39:05.164] length: 0 (resolved future 1)
[21:39:05.165] resolve() on list ... DONE
[21:39:05.165] - '...' content: [n=0]
[21:39:05.165] List of 1
[21:39:05.165] $ ...: list()
[21:39:05.165] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:05.165] - attr(*, "where")=List of 1
[21:39:05.165] ..$ ...:<environment: 0x55c1f03848c8>
[21:39:05.165] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:05.165] - attr(*, "resolved")= logi TRUE
[21:39:05.165] - attr(*, "total_size")= num NA
[21:39:05.187] - Getting '...' globals ... DONE
[21:39:05.187] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[21:39:05.187] List of 2
[21:39:05.187] $ ...future.FUN:function (x)
[21:39:05.187] $ ... : list()
[21:39:05.187] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:05.187] - attr(*, "where")=List of 2
[21:39:05.187] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:05.187] ..$ ... :<environment: 0x55c1f03848c8>
[21:39:05.187] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:05.187] - attr(*, "resolved")= logi FALSE
[21:39:05.187] - attr(*, "total_size")= num 4720
[21:39:05.194] Packages to be attached in all futures: [n=0]
[21:39:05.195] getGlobalsAndPackagesXApply() ... DONE
[21:39:05.195] Number of futures (= number of chunks): 1
[21:39:05.196] Launching 1 futures (chunks) ...
[21:39:05.196] Chunk #1 of 1 ...
[21:39:05.196] - Finding globals in 'X' for chunk #1 ...
[21:39:05.196] getGlobalsAndPackages() ...
[21:39:05.197] Searching for globals...
[21:39:05.197]
[21:39:05.197] Searching for globals ... DONE
[21:39:05.198] - globals: [0] <none>
[21:39:05.198] getGlobalsAndPackages() ... DONE
[21:39:05.198] + additional globals found: [n=0]
[21:39:05.198] + additional namespaces needed: [n=0]
[21:39:05.198] - Finding globals in 'X' for chunk #1 ... DONE
[21:39:05.199] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:05.199] - seeds: <none>
[21:39:05.199] getGlobalsAndPackages() ...
[21:39:05.199] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:05.200] Resolving globals: FALSE
[21:39:05.200] Tweak future expression to call with '...' arguments ...
[21:39:05.200] {
[21:39:05.200] do.call(function(...) {
[21:39:05.200] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:05.200] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:05.200] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:05.200] on.exit(options(oopts), add = TRUE)
[21:39:05.200] }
[21:39:05.200] {
[21:39:05.200] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:05.200] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:05.200] ...future.FUN(...future.X_jj, ...)
[21:39:05.200] })
[21:39:05.200] }
[21:39:05.200] }, args = future.call.arguments)
[21:39:05.200] }
[21:39:05.201] Tweak future expression to call with '...' arguments ... DONE
[21:39:05.202] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:05.202]
[21:39:05.202] getGlobalsAndPackages() ... DONE
[21:39:05.219] run() for 'Future' ...
[21:39:05.219] - state: 'created'
[21:39:05.220] - Future backend: 'FutureStrategy', 'multicore', 'multiprocess', 'future', 'function'
[21:39:05.251] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:05.252] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:05.252] - Field: 'label'
[21:39:05.252] - Field: 'local'
[21:39:05.252] - Field: 'owner'
[21:39:05.253] - Field: 'envir'
[21:39:05.253] - Field: 'packages'
[21:39:05.253] - Field: 'gc'
[21:39:05.253] - Field: 'conditions'
[21:39:05.254] - Field: 'expr'
[21:39:05.254] - Field: 'uuid'
[21:39:05.254] - Field: 'seed'
[21:39:05.254] - Field: 'version'
[21:39:05.255] - Field: 'result'
[21:39:05.255] - Field: 'asynchronous'
[21:39:05.255] - Field: 'calls'
[21:39:05.255] - Field: 'globals'
[21:39:05.256] - Field: 'stdout'
[21:39:05.256] - Field: 'earlySignal'
[21:39:05.256] - Field: 'lazy'
[21:39:05.256] - Field: 'state'
[21:39:05.256] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:05.257] - Launch lazy future ...
[21:39:05.257] Packages needed by the future expression (n = 0): <none>
[21:39:05.257] Packages needed by future strategies (n = 0): <none>
[21:39:05.258] {
[21:39:05.258] {
[21:39:05.258] {
[21:39:05.258] ...future.startTime <- base::Sys.time()
[21:39:05.258] {
[21:39:05.258] {
[21:39:05.258] {
[21:39:05.258] base::local({
[21:39:05.258] has_future <- base::requireNamespace("future",
[21:39:05.258] quietly = TRUE)
[21:39:05.258] if (has_future) {
[21:39:05.258] ns <- base::getNamespace("future")
[21:39:05.258] version <- ns[[".package"]][["version"]]
[21:39:05.258] if (is.null(version))
[21:39:05.258] version <- utils::packageVersion("future")
[21:39:05.258] }
[21:39:05.258] else {
[21:39:05.258] version <- NULL
[21:39:05.258] }
[21:39:05.258] if (!has_future || version < "1.8.0") {
[21:39:05.258] info <- base::c(r_version = base::gsub("R version ",
[21:39:05.258] "", base::R.version$version.string),
[21:39:05.258] platform = base::sprintf("%s (%s-bit)",
[21:39:05.258] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:05.258] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:05.258] "release", "version")], collapse = " "),
[21:39:05.258] hostname = base::Sys.info()[["nodename"]])
[21:39:05.258] info <- base::sprintf("%s: %s", base::names(info),
[21:39:05.258] info)
[21:39:05.258] info <- base::paste(info, collapse = "; ")
[21:39:05.258] if (!has_future) {
[21:39:05.258] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:05.258] info)
[21:39:05.258] }
[21:39:05.258] else {
[21:39:05.258] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:05.258] info, version)
[21:39:05.258] }
[21:39:05.258] base::stop(msg)
[21:39:05.258] }
[21:39:05.258] })
[21:39:05.258] }
[21:39:05.258] options(future.plan = NULL)
[21:39:05.258] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:05.258] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:05.258] }
[21:39:05.258] ...future.workdir <- getwd()
[21:39:05.258] }
[21:39:05.258] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:05.258] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:05.258] }
[21:39:05.258] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:05.258] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:05.258] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:05.258] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:05.258] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:05.258] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:05.258] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:05.258] base::names(...future.oldOptions))
[21:39:05.258] }
[21:39:05.258] if (FALSE) {
[21:39:05.258] }
[21:39:05.258] else {
[21:39:05.258] if (FALSE) {
[21:39:05.258] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:05.258] open = "w")
[21:39:05.258] }
[21:39:05.258] else {
[21:39:05.258] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:05.258] windows = "NUL", "/dev/null"), open = "w")
[21:39:05.258] }
[21:39:05.258] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:05.258] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:05.258] base::sink(type = "output", split = FALSE)
[21:39:05.258] base::close(...future.stdout)
[21:39:05.258] }, add = TRUE)
[21:39:05.258] }
[21:39:05.258] ...future.frame <- base::sys.nframe()
[21:39:05.258] ...future.conditions <- base::list()
[21:39:05.258] ...future.rng <- base::globalenv()$.Random.seed
[21:39:05.258] if (FALSE) {
[21:39:05.258] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:05.258] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:05.258] }
[21:39:05.258] ...future.result <- base::tryCatch({
[21:39:05.258] base::withCallingHandlers({
[21:39:05.258] ...future.value <- base::withVisible(base::local({
[21:39:05.258] do.call(function(...) {
[21:39:05.258] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:05.258] if (!identical(...future.globals.maxSize.org,
[21:39:05.258] ...future.globals.maxSize)) {
[21:39:05.258] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:05.258] on.exit(options(oopts), add = TRUE)
[21:39:05.258] }
[21:39:05.258] {
[21:39:05.258] lapply(seq_along(...future.elements_ii),
[21:39:05.258] FUN = function(jj) {
[21:39:05.258] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:05.258] ...future.FUN(...future.X_jj, ...)
[21:39:05.258] })
[21:39:05.258] }
[21:39:05.258] }, args = future.call.arguments)
[21:39:05.258] }))
[21:39:05.258] future::FutureResult(value = ...future.value$value,
[21:39:05.258] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:05.258] ...future.rng), globalenv = if (FALSE)
[21:39:05.258] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:05.258] ...future.globalenv.names))
[21:39:05.258] else NULL, started = ...future.startTime, version = "1.8")
[21:39:05.258] }, condition = base::local({
[21:39:05.258] c <- base::c
[21:39:05.258] inherits <- base::inherits
[21:39:05.258] invokeRestart <- base::invokeRestart
[21:39:05.258] length <- base::length
[21:39:05.258] list <- base::list
[21:39:05.258] seq.int <- base::seq.int
[21:39:05.258] signalCondition <- base::signalCondition
[21:39:05.258] sys.calls <- base::sys.calls
[21:39:05.258] `[[` <- base::`[[`
[21:39:05.258] `+` <- base::`+`
[21:39:05.258] `<<-` <- base::`<<-`
[21:39:05.258] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:05.258] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:05.258] 3L)]
[21:39:05.258] }
[21:39:05.258] function(cond) {
[21:39:05.258] is_error <- inherits(cond, "error")
[21:39:05.258] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:05.258] NULL)
[21:39:05.258] if (is_error) {
[21:39:05.258] sessionInformation <- function() {
[21:39:05.258] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:05.258] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:05.258] search = base::search(), system = base::Sys.info())
[21:39:05.258] }
[21:39:05.258] ...future.conditions[[length(...future.conditions) +
[21:39:05.258] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:05.258] cond$call), session = sessionInformation(),
[21:39:05.258] timestamp = base::Sys.time(), signaled = 0L)
[21:39:05.258] signalCondition(cond)
[21:39:05.258] }
[21:39:05.258] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:05.258] "immediateCondition"))) {
[21:39:05.258] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:05.258] ...future.conditions[[length(...future.conditions) +
[21:39:05.258] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:05.258] if (TRUE && !signal) {
[21:39:05.258] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:05.258] {
[21:39:05.258] inherits <- base::inherits
[21:39:05.258] invokeRestart <- base::invokeRestart
[21:39:05.258] is.null <- base::is.null
[21:39:05.258] muffled <- FALSE
[21:39:05.258] if (inherits(cond, "message")) {
[21:39:05.258] muffled <- grepl(pattern, "muffleMessage")
[21:39:05.258] if (muffled)
[21:39:05.258] invokeRestart("muffleMessage")
[21:39:05.258] }
[21:39:05.258] else if (inherits(cond, "warning")) {
[21:39:05.258] muffled <- grepl(pattern, "muffleWarning")
[21:39:05.258] if (muffled)
[21:39:05.258] invokeRestart("muffleWarning")
[21:39:05.258] }
[21:39:05.258] else if (inherits(cond, "condition")) {
[21:39:05.258] if (!is.null(pattern)) {
[21:39:05.258] computeRestarts <- base::computeRestarts
[21:39:05.258] grepl <- base::grepl
[21:39:05.258] restarts <- computeRestarts(cond)
[21:39:05.258] for (restart in restarts) {
[21:39:05.258] name <- restart$name
[21:39:05.258] if (is.null(name))
[21:39:05.258] next
[21:39:05.258] if (!grepl(pattern, name))
[21:39:05.258] next
[21:39:05.258] invokeRestart(restart)
[21:39:05.258] muffled <- TRUE
[21:39:05.258] break
[21:39:05.258] }
[21:39:05.258] }
[21:39:05.258] }
[21:39:05.258] invisible(muffled)
[21:39:05.258] }
[21:39:05.258] muffleCondition(cond, pattern = "^muffle")
[21:39:05.258] }
[21:39:05.258] }
[21:39:05.258] else {
[21:39:05.258] if (TRUE) {
[21:39:05.258] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:05.258] {
[21:39:05.258] inherits <- base::inherits
[21:39:05.258] invokeRestart <- base::invokeRestart
[21:39:05.258] is.null <- base::is.null
[21:39:05.258] muffled <- FALSE
[21:39:05.258] if (inherits(cond, "message")) {
[21:39:05.258] muffled <- grepl(pattern, "muffleMessage")
[21:39:05.258] if (muffled)
[21:39:05.258] invokeRestart("muffleMessage")
[21:39:05.258] }
[21:39:05.258] else if (inherits(cond, "warning")) {
[21:39:05.258] muffled <- grepl(pattern, "muffleWarning")
[21:39:05.258] if (muffled)
[21:39:05.258] invokeRestart("muffleWarning")
[21:39:05.258] }
[21:39:05.258] else if (inherits(cond, "condition")) {
[21:39:05.258] if (!is.null(pattern)) {
[21:39:05.258] computeRestarts <- base::computeRestarts
[21:39:05.258] grepl <- base::grepl
[21:39:05.258] restarts <- computeRestarts(cond)
[21:39:05.258] for (restart in restarts) {
[21:39:05.258] name <- restart$name
[21:39:05.258] if (is.null(name))
[21:39:05.258] next
[21:39:05.258] if (!grepl(pattern, name))
[21:39:05.258] next
[21:39:05.258] invokeRestart(restart)
[21:39:05.258] muffled <- TRUE
[21:39:05.258] break
[21:39:05.258] }
[21:39:05.258] }
[21:39:05.258] }
[21:39:05.258] invisible(muffled)
[21:39:05.258] }
[21:39:05.258] muffleCondition(cond, pattern = "^muffle")
[21:39:05.258] }
[21:39:05.258] }
[21:39:05.258] }
[21:39:05.258] }))
[21:39:05.258] }, error = function(ex) {
[21:39:05.258] base::structure(base::list(value = NULL, visible = NULL,
[21:39:05.258] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:05.258] ...future.rng), started = ...future.startTime,
[21:39:05.258] finished = Sys.time(), session_uuid = NA_character_,
[21:39:05.258] version = "1.8"), class = "FutureResult")
[21:39:05.258] }, finally = {
[21:39:05.258] if (!identical(...future.workdir, getwd()))
[21:39:05.258] setwd(...future.workdir)
[21:39:05.258] {
[21:39:05.258] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:05.258] ...future.oldOptions$nwarnings <- NULL
[21:39:05.258] }
[21:39:05.258] base::options(...future.oldOptions)
[21:39:05.258] if (.Platform$OS.type == "windows") {
[21:39:05.258] old_names <- names(...future.oldEnvVars)
[21:39:05.258] envs <- base::Sys.getenv()
[21:39:05.258] names <- names(envs)
[21:39:05.258] common <- intersect(names, old_names)
[21:39:05.258] added <- setdiff(names, old_names)
[21:39:05.258] removed <- setdiff(old_names, names)
[21:39:05.258] changed <- common[...future.oldEnvVars[common] !=
[21:39:05.258] envs[common]]
[21:39:05.258] NAMES <- toupper(changed)
[21:39:05.258] args <- list()
[21:39:05.258] for (kk in seq_along(NAMES)) {
[21:39:05.258] name <- changed[[kk]]
[21:39:05.258] NAME <- NAMES[[kk]]
[21:39:05.258] if (name != NAME && is.element(NAME, old_names))
[21:39:05.258] next
[21:39:05.258] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:05.258] }
[21:39:05.258] NAMES <- toupper(added)
[21:39:05.258] for (kk in seq_along(NAMES)) {
[21:39:05.258] name <- added[[kk]]
[21:39:05.258] NAME <- NAMES[[kk]]
[21:39:05.258] if (name != NAME && is.element(NAME, old_names))
[21:39:05.258] next
[21:39:05.258] args[[name]] <- ""
[21:39:05.258] }
[21:39:05.258] NAMES <- toupper(removed)
[21:39:05.258] for (kk in seq_along(NAMES)) {
[21:39:05.258] name <- removed[[kk]]
[21:39:05.258] NAME <- NAMES[[kk]]
[21:39:05.258] if (name != NAME && is.element(NAME, old_names))
[21:39:05.258] next
[21:39:05.258] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:05.258] }
[21:39:05.258] if (length(args) > 0)
[21:39:05.258] base::do.call(base::Sys.setenv, args = args)
[21:39:05.258] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:05.258] }
[21:39:05.258] else {
[21:39:05.258] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:05.258] }
[21:39:05.258] {
[21:39:05.258] if (base::length(...future.futureOptionsAdded) >
[21:39:05.258] 0L) {
[21:39:05.258] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:05.258] base::names(opts) <- ...future.futureOptionsAdded
[21:39:05.258] base::options(opts)
[21:39:05.258] }
[21:39:05.258] {
[21:39:05.258] {
[21:39:05.258] NULL
[21:39:05.258] RNGkind("Mersenne-Twister")
[21:39:05.258] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:05.258] inherits = FALSE)
[21:39:05.258] }
[21:39:05.258] options(future.plan = NULL)
[21:39:05.258] if (is.na(NA_character_))
[21:39:05.258] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:05.258] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:05.258] future::plan(list(function (..., workers = availableCores(constraints = "multicore"),
[21:39:05.258] envir = parent.frame())
[21:39:05.258] {
[21:39:05.258] default_workers <- missing(workers)
[21:39:05.258] if (is.function(workers))
[21:39:05.258] workers <- workers()
[21:39:05.258] workers <- structure(as.integer(workers),
[21:39:05.258] class = class(workers))
[21:39:05.258] stop_if_not(is.finite(workers), workers >=
[21:39:05.258] 1L)
[21:39:05.258] if ((workers == 1L && !inherits(workers,
[21:39:05.258] "AsIs")) || !supportsMulticore(warn = TRUE)) {
[21:39:05.258] if (default_workers)
[21:39:05.258] supportsMulticore(warn = TRUE)
[21:39:05.258] return(sequential(..., envir = envir))
[21:39:05.258] }
[21:39:05.258] oopts <- options(mc.cores = workers)
[21:39:05.258] on.exit(options(oopts))
[21:39:05.258] future <- MulticoreFuture(..., workers = workers,
[21:39:05.258] envir = envir)
[21:39:05.258] if (!future$lazy)
[21:39:05.258] future <- run(future)
[21:39:05.258] invisible(future)
[21:39:05.258] }), .cleanup = FALSE, .init = FALSE)
[21:39:05.258] }
[21:39:05.258] }
[21:39:05.258] }
[21:39:05.258] })
[21:39:05.258] if (TRUE) {
[21:39:05.258] base::sink(type = "output", split = FALSE)
[21:39:05.258] if (FALSE) {
[21:39:05.258] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:05.258] }
[21:39:05.258] else {
[21:39:05.258] ...future.result["stdout"] <- base::list(NULL)
[21:39:05.258] }
[21:39:05.258] base::close(...future.stdout)
[21:39:05.258] ...future.stdout <- NULL
[21:39:05.258] }
[21:39:05.258] ...future.result$conditions <- ...future.conditions
[21:39:05.258] ...future.result$finished <- base::Sys.time()
[21:39:05.258] ...future.result
[21:39:05.258] }
[21:39:05.262] assign_globals() ...
[21:39:05.262] List of 5
[21:39:05.262] $ ...future.FUN :function (x)
[21:39:05.262] $ future.call.arguments : list()
[21:39:05.262] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:05.262] $ ...future.elements_ii :List of 2
[21:39:05.262] ..$ : int 1
[21:39:05.262] ..$ : int 0
[21:39:05.262] $ ...future.seeds_ii : NULL
[21:39:05.262] $ ...future.globals.maxSize: NULL
[21:39:05.262] - attr(*, "resolved")= logi FALSE
[21:39:05.262] - attr(*, "total_size")= num 4720
[21:39:05.262] - attr(*, "where")=List of 5
[21:39:05.262] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:05.262] ..$ future.call.arguments :<environment: R_EmptyEnv>
[21:39:05.262] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:05.262] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:05.262] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:05.262] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:05.262] - attr(*, "already-done")= logi TRUE
[21:39:05.287] - reassign environment for '...future.FUN'
[21:39:05.287] - copied '...future.FUN' to environment
[21:39:05.288] - copied 'future.call.arguments' to environment
[21:39:05.288] - copied '...future.elements_ii' to environment
[21:39:05.288] - copied '...future.seeds_ii' to environment
[21:39:05.288] - copied '...future.globals.maxSize' to environment
[21:39:05.288] assign_globals() ... done
[21:39:05.289] plan(): Setting new future strategy stack:
[21:39:05.289] List of future strategies:
[21:39:05.289] 1. sequential:
[21:39:05.289] - args: function (..., envir = parent.frame())
[21:39:05.289] - tweaked: FALSE
[21:39:05.289] - call: NULL
[21:39:05.290] plan(): nbrOfWorkers() = 1
[21:39:05.792] plan(): Setting new future strategy stack:
[21:39:05.792] List of future strategies:
[21:39:05.792] 1. multicore:
[21:39:05.792] - args: function (..., workers = availableCores(constraints = "multicore"), envir = parent.frame())
[21:39:05.792] - tweaked: FALSE
[21:39:05.792] - call: plan(strategy)
[21:39:05.837] plan(): nbrOfWorkers() = 1
[21:39:05.838] SequentialFuture started (and completed)
[21:39:05.838] - Launch lazy future ... done
[21:39:05.838] run() for 'SequentialFuture' ... done
[21:39:05.839] Created future:
[21:39:05.839] SequentialFuture:
[21:39:05.839] Label: 'future_lapply-1'
[21:39:05.839] Expression:
[21:39:05.839] {
[21:39:05.839] do.call(function(...) {
[21:39:05.839] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:05.839] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:05.839] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:05.839] on.exit(options(oopts), add = TRUE)
[21:39:05.839] }
[21:39:05.839] {
[21:39:05.839] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:05.839] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:05.839] ...future.FUN(...future.X_jj, ...)
[21:39:05.839] })
[21:39:05.839] }
[21:39:05.839] }, args = future.call.arguments)
[21:39:05.839] }
[21:39:05.839] Lazy evaluation: FALSE
[21:39:05.839] Asynchronous evaluation: FALSE
[21:39:05.839] Local evaluation: TRUE
[21:39:05.839] Environment: R_GlobalEnv
[21:39:05.839] Capture standard output: FALSE
[21:39:05.839] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:05.839] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:05.839] Packages: <none>
[21:39:05.839] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:05.839] Resolved: TRUE
[21:39:05.839] Value: 112 bytes of class 'list'
[21:39:05.839] Early signaling: FALSE
[21:39:05.839] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:05.839] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:05.841] Chunk #1 of 1 ... DONE
[21:39:05.841] Launching 1 futures (chunks) ... DONE
[21:39:05.842] Resolving 1 futures (chunks) ...
[21:39:05.842] resolve() on list ...
[21:39:05.842] recursive: 0
[21:39:05.842] length: 1
[21:39:05.843]
[21:39:05.843] resolved() for 'SequentialFuture' ...
[21:39:05.843] - state: 'finished'
[21:39:05.843] - run: TRUE
[21:39:05.844] - result: 'FutureResult'
[21:39:05.844] resolved() for 'SequentialFuture' ... done
[21:39:05.844] Future #1
[21:39:05.844] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:05.845] - nx: 1
[21:39:05.845] - relay: TRUE
[21:39:05.845] - stdout: TRUE
[21:39:05.845] - signal: TRUE
[21:39:05.846] - resignal: FALSE
[21:39:05.846] - force: TRUE
[21:39:05.846] - relayed: [n=1] FALSE
[21:39:05.846] - queued futures: [n=1] FALSE
[21:39:05.846] - until=1
[21:39:05.847] - relaying element #1
[21:39:05.847] - relayed: [n=1] TRUE
[21:39:05.847] - queued futures: [n=1] TRUE
[21:39:05.848] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:05.848] length: 0 (resolved future 1)
[21:39:05.848] Relaying remaining futures
[21:39:05.848] signalConditionsASAP(NULL, pos=0) ...
[21:39:05.849] - nx: 1
[21:39:05.849] - relay: TRUE
[21:39:05.849] - stdout: TRUE
[21:39:05.849] - signal: TRUE
[21:39:05.849] - resignal: FALSE
[21:39:05.850] - force: TRUE
[21:39:05.850] - relayed: [n=1] TRUE
[21:39:05.850] - queued futures: [n=1] TRUE
- flush all
[21:39:05.858] - relayed: [n=1] TRUE
[21:39:05.859] - queued futures: [n=1] TRUE
[21:39:05.859] signalConditionsASAP(NULL, pos=0) ... done
[21:39:05.859] resolve() on list ... DONE
[21:39:05.860] - Number of value chunks collected: 1
[21:39:05.860] Resolving 1 futures (chunks) ... DONE
[21:39:05.860] Reducing values from 1 chunks ...
[21:39:05.860] - Number of values collected after concatenation: 2
[21:39:05.861] - Number of values expected: 2
[21:39:05.861] Reducing values from 1 chunks ... DONE
[21:39:05.861] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = FALSE) ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ...
[21:39:05.862] future_lapply() ...
[21:39:05.898] Number of chunks: 1
[21:39:05.898] getGlobalsAndPackagesXApply() ...
[21:39:05.898] - future.globals: TRUE
[21:39:05.899] getGlobalsAndPackages() ...
[21:39:05.899] Searching for globals...
[21:39:05.902] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[21:39:05.903] Searching for globals ... DONE
[21:39:05.903] Resolving globals: FALSE
[21:39:05.904] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[21:39:05.904] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[21:39:05.905] - globals: [1] 'FUN'
[21:39:05.905]
[21:39:05.905] getGlobalsAndPackages() ... DONE
[21:39:05.905] - globals found/used: [n=1] 'FUN'
[21:39:05.906] - needed namespaces: [n=0]
[21:39:05.906] Finding globals ... DONE
[21:39:05.906] - use_args: TRUE
[21:39:05.906] - Getting '...' globals ...
[21:39:05.907] resolve() on list ...
[21:39:05.907] recursive: 0
[21:39:05.908] length: 1
[21:39:05.908] elements: '...'
[21:39:05.908] length: 0 (resolved future 1)
[21:39:05.908] resolve() on list ... DONE
[21:39:05.909] - '...' content: [n=0]
[21:39:05.909] List of 1
[21:39:05.909] $ ...: list()
[21:39:05.909] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:05.909] - attr(*, "where")=List of 1
[21:39:05.909] ..$ ...:<environment: 0x55c1efeda7c8>
[21:39:05.909] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:05.909] - attr(*, "resolved")= logi TRUE
[21:39:05.909] - attr(*, "total_size")= num NA
[21:39:05.927] - Getting '...' globals ... DONE
[21:39:05.927] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[21:39:05.928] List of 2
[21:39:05.928] $ ...future.FUN:function (x)
[21:39:05.928] $ ... : list()
[21:39:05.928] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:05.928] - attr(*, "where")=List of 2
[21:39:05.928] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:05.928] ..$ ... :<environment: 0x55c1efeda7c8>
[21:39:05.928] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:05.928] - attr(*, "resolved")= logi FALSE
[21:39:05.928] - attr(*, "total_size")= num 4720
[21:39:05.934] Packages to be attached in all futures: [n=0]
[21:39:05.934] getGlobalsAndPackagesXApply() ... DONE
[21:39:05.968] Number of futures (= number of chunks): 1
[21:39:05.969] Launching 1 futures (chunks) ...
[21:39:05.969] Chunk #1 of 1 ...
[21:39:05.969] - Finding globals in 'X' for chunk #1 ...
[21:39:05.969] getGlobalsAndPackages() ...
[21:39:05.970] Searching for globals...
[21:39:05.970]
[21:39:05.971] Searching for globals ... DONE
[21:39:05.971] - globals: [0] <none>
[21:39:05.971] getGlobalsAndPackages() ... DONE
[21:39:05.975] + additional globals found: [n=0]
[21:39:05.975] + additional namespaces needed: [n=0]
[21:39:05.975] - Finding globals in 'X' for chunk #1 ... DONE
[21:39:05.975] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:05.976] - seeds: <none>
[21:39:05.976] getGlobalsAndPackages() ...
[21:39:05.976] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:05.976] Resolving globals: FALSE
[21:39:05.977] Tweak future expression to call with '...' arguments ...
[21:39:05.977] {
[21:39:05.977] do.call(function(...) {
[21:39:05.977] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:05.977] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:05.977] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:05.977] on.exit(options(oopts), add = TRUE)
[21:39:05.977] }
[21:39:05.977] {
[21:39:05.977] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:05.977] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:05.977] ...future.FUN(...future.X_jj, ...)
[21:39:05.977] })
[21:39:05.977] }
[21:39:05.977] }, args = future.call.arguments)
[21:39:05.977] }
[21:39:05.978] Tweak future expression to call with '...' arguments ... DONE
[21:39:05.978] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:05.979]
[21:39:05.979] getGlobalsAndPackages() ... DONE
[21:39:05.979] run() for 'Future' ...
[21:39:05.980] - state: 'created'
[21:39:05.980] - Future backend: 'FutureStrategy', 'multicore', 'multiprocess', 'future', 'function'
[21:39:06.007] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:06.007] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:06.008] - Field: 'label'
[21:39:06.008] - Field: 'local'
[21:39:06.008] - Field: 'owner'
[21:39:06.008] - Field: 'envir'
[21:39:06.009] - Field: 'packages'
[21:39:06.009] - Field: 'gc'
[21:39:06.009] - Field: 'conditions'
[21:39:06.009] - Field: 'expr'
[21:39:06.010] - Field: 'uuid'
[21:39:06.010] - Field: 'seed'
[21:39:06.010] - Field: 'version'
[21:39:06.010] - Field: 'result'
[21:39:06.010] - Field: 'asynchronous'
[21:39:06.011] - Field: 'calls'
[21:39:06.011] - Field: 'globals'
[21:39:06.011] - Field: 'stdout'
[21:39:06.011] - Field: 'earlySignal'
[21:39:06.012] - Field: 'lazy'
[21:39:06.012] - Field: 'state'
[21:39:06.012] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:06.012] - Launch lazy future ...
[21:39:06.013] Packages needed by the future expression (n = 0): <none>
[21:39:06.013] Packages needed by future strategies (n = 0): <none>
[21:39:06.014] {
[21:39:06.014] {
[21:39:06.014] {
[21:39:06.014] ...future.startTime <- base::Sys.time()
[21:39:06.014] {
[21:39:06.014] {
[21:39:06.014] {
[21:39:06.014] base::local({
[21:39:06.014] has_future <- base::requireNamespace("future",
[21:39:06.014] quietly = TRUE)
[21:39:06.014] if (has_future) {
[21:39:06.014] ns <- base::getNamespace("future")
[21:39:06.014] version <- ns[[".package"]][["version"]]
[21:39:06.014] if (is.null(version))
[21:39:06.014] version <- utils::packageVersion("future")
[21:39:06.014] }
[21:39:06.014] else {
[21:39:06.014] version <- NULL
[21:39:06.014] }
[21:39:06.014] if (!has_future || version < "1.8.0") {
[21:39:06.014] info <- base::c(r_version = base::gsub("R version ",
[21:39:06.014] "", base::R.version$version.string),
[21:39:06.014] platform = base::sprintf("%s (%s-bit)",
[21:39:06.014] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:06.014] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:06.014] "release", "version")], collapse = " "),
[21:39:06.014] hostname = base::Sys.info()[["nodename"]])
[21:39:06.014] info <- base::sprintf("%s: %s", base::names(info),
[21:39:06.014] info)
[21:39:06.014] info <- base::paste(info, collapse = "; ")
[21:39:06.014] if (!has_future) {
[21:39:06.014] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:06.014] info)
[21:39:06.014] }
[21:39:06.014] else {
[21:39:06.014] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:06.014] info, version)
[21:39:06.014] }
[21:39:06.014] base::stop(msg)
[21:39:06.014] }
[21:39:06.014] })
[21:39:06.014] }
[21:39:06.014] options(future.plan = NULL)
[21:39:06.014] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:06.014] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:06.014] }
[21:39:06.014] ...future.workdir <- getwd()
[21:39:06.014] }
[21:39:06.014] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:06.014] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:06.014] }
[21:39:06.014] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:06.014] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:06.014] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:06.014] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:06.014] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:06.014] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:06.014] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:06.014] base::names(...future.oldOptions))
[21:39:06.014] }
[21:39:06.014] if (FALSE) {
[21:39:06.014] }
[21:39:06.014] else {
[21:39:06.014] if (TRUE) {
[21:39:06.014] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:06.014] open = "w")
[21:39:06.014] }
[21:39:06.014] else {
[21:39:06.014] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:06.014] windows = "NUL", "/dev/null"), open = "w")
[21:39:06.014] }
[21:39:06.014] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:06.014] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:06.014] base::sink(type = "output", split = FALSE)
[21:39:06.014] base::close(...future.stdout)
[21:39:06.014] }, add = TRUE)
[21:39:06.014] }
[21:39:06.014] ...future.frame <- base::sys.nframe()
[21:39:06.014] ...future.conditions <- base::list()
[21:39:06.014] ...future.rng <- base::globalenv()$.Random.seed
[21:39:06.014] if (FALSE) {
[21:39:06.014] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:06.014] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:06.014] }
[21:39:06.014] ...future.result <- base::tryCatch({
[21:39:06.014] base::withCallingHandlers({
[21:39:06.014] ...future.value <- base::withVisible(base::local({
[21:39:06.014] do.call(function(...) {
[21:39:06.014] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:06.014] if (!identical(...future.globals.maxSize.org,
[21:39:06.014] ...future.globals.maxSize)) {
[21:39:06.014] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:06.014] on.exit(options(oopts), add = TRUE)
[21:39:06.014] }
[21:39:06.014] {
[21:39:06.014] lapply(seq_along(...future.elements_ii),
[21:39:06.014] FUN = function(jj) {
[21:39:06.014] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:06.014] ...future.FUN(...future.X_jj, ...)
[21:39:06.014] })
[21:39:06.014] }
[21:39:06.014] }, args = future.call.arguments)
[21:39:06.014] }))
[21:39:06.014] future::FutureResult(value = ...future.value$value,
[21:39:06.014] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:06.014] ...future.rng), globalenv = if (FALSE)
[21:39:06.014] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:06.014] ...future.globalenv.names))
[21:39:06.014] else NULL, started = ...future.startTime, version = "1.8")
[21:39:06.014] }, condition = base::local({
[21:39:06.014] c <- base::c
[21:39:06.014] inherits <- base::inherits
[21:39:06.014] invokeRestart <- base::invokeRestart
[21:39:06.014] length <- base::length
[21:39:06.014] list <- base::list
[21:39:06.014] seq.int <- base::seq.int
[21:39:06.014] signalCondition <- base::signalCondition
[21:39:06.014] sys.calls <- base::sys.calls
[21:39:06.014] `[[` <- base::`[[`
[21:39:06.014] `+` <- base::`+`
[21:39:06.014] `<<-` <- base::`<<-`
[21:39:06.014] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:06.014] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:06.014] 3L)]
[21:39:06.014] }
[21:39:06.014] function(cond) {
[21:39:06.014] is_error <- inherits(cond, "error")
[21:39:06.014] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:06.014] NULL)
[21:39:06.014] if (is_error) {
[21:39:06.014] sessionInformation <- function() {
[21:39:06.014] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:06.014] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:06.014] search = base::search(), system = base::Sys.info())
[21:39:06.014] }
[21:39:06.014] ...future.conditions[[length(...future.conditions) +
[21:39:06.014] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:06.014] cond$call), session = sessionInformation(),
[21:39:06.014] timestamp = base::Sys.time(), signaled = 0L)
[21:39:06.014] signalCondition(cond)
[21:39:06.014] }
[21:39:06.014] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:06.014] "immediateCondition"))) {
[21:39:06.014] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:06.014] ...future.conditions[[length(...future.conditions) +
[21:39:06.014] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:06.014] if (TRUE && !signal) {
[21:39:06.014] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:06.014] {
[21:39:06.014] inherits <- base::inherits
[21:39:06.014] invokeRestart <- base::invokeRestart
[21:39:06.014] is.null <- base::is.null
[21:39:06.014] muffled <- FALSE
[21:39:06.014] if (inherits(cond, "message")) {
[21:39:06.014] muffled <- grepl(pattern, "muffleMessage")
[21:39:06.014] if (muffled)
[21:39:06.014] invokeRestart("muffleMessage")
[21:39:06.014] }
[21:39:06.014] else if (inherits(cond, "warning")) {
[21:39:06.014] muffled <- grepl(pattern, "muffleWarning")
[21:39:06.014] if (muffled)
[21:39:06.014] invokeRestart("muffleWarning")
[21:39:06.014] }
[21:39:06.014] else if (inherits(cond, "condition")) {
[21:39:06.014] if (!is.null(pattern)) {
[21:39:06.014] computeRestarts <- base::computeRestarts
[21:39:06.014] grepl <- base::grepl
[21:39:06.014] restarts <- computeRestarts(cond)
[21:39:06.014] for (restart in restarts) {
[21:39:06.014] name <- restart$name
[21:39:06.014] if (is.null(name))
[21:39:06.014] next
[21:39:06.014] if (!grepl(pattern, name))
[21:39:06.014] next
[21:39:06.014] invokeRestart(restart)
[21:39:06.014] muffled <- TRUE
[21:39:06.014] break
[21:39:06.014] }
[21:39:06.014] }
[21:39:06.014] }
[21:39:06.014] invisible(muffled)
[21:39:06.014] }
[21:39:06.014] muffleCondition(cond, pattern = "^muffle")
[21:39:06.014] }
[21:39:06.014] }
[21:39:06.014] else {
[21:39:06.014] if (TRUE) {
[21:39:06.014] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:06.014] {
[21:39:06.014] inherits <- base::inherits
[21:39:06.014] invokeRestart <- base::invokeRestart
[21:39:06.014] is.null <- base::is.null
[21:39:06.014] muffled <- FALSE
[21:39:06.014] if (inherits(cond, "message")) {
[21:39:06.014] muffled <- grepl(pattern, "muffleMessage")
[21:39:06.014] if (muffled)
[21:39:06.014] invokeRestart("muffleMessage")
[21:39:06.014] }
[21:39:06.014] else if (inherits(cond, "warning")) {
[21:39:06.014] muffled <- grepl(pattern, "muffleWarning")
[21:39:06.014] if (muffled)
[21:39:06.014] invokeRestart("muffleWarning")
[21:39:06.014] }
[21:39:06.014] else if (inherits(cond, "condition")) {
[21:39:06.014] if (!is.null(pattern)) {
[21:39:06.014] computeRestarts <- base::computeRestarts
[21:39:06.014] grepl <- base::grepl
[21:39:06.014] restarts <- computeRestarts(cond)
[21:39:06.014] for (restart in restarts) {
[21:39:06.014] name <- restart$name
[21:39:06.014] if (is.null(name))
[21:39:06.014] next
[21:39:06.014] if (!grepl(pattern, name))
[21:39:06.014] next
[21:39:06.014] invokeRestart(restart)
[21:39:06.014] muffled <- TRUE
[21:39:06.014] break
[21:39:06.014] }
[21:39:06.014] }
[21:39:06.014] }
[21:39:06.014] invisible(muffled)
[21:39:06.014] }
[21:39:06.014] muffleCondition(cond, pattern = "^muffle")
[21:39:06.014] }
[21:39:06.014] }
[21:39:06.014] }
[21:39:06.014] }))
[21:39:06.014] }, error = function(ex) {
[21:39:06.014] base::structure(base::list(value = NULL, visible = NULL,
[21:39:06.014] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:06.014] ...future.rng), started = ...future.startTime,
[21:39:06.014] finished = Sys.time(), session_uuid = NA_character_,
[21:39:06.014] version = "1.8"), class = "FutureResult")
[21:39:06.014] }, finally = {
[21:39:06.014] if (!identical(...future.workdir, getwd()))
[21:39:06.014] setwd(...future.workdir)
[21:39:06.014] {
[21:39:06.014] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:06.014] ...future.oldOptions$nwarnings <- NULL
[21:39:06.014] }
[21:39:06.014] base::options(...future.oldOptions)
[21:39:06.014] if (.Platform$OS.type == "windows") {
[21:39:06.014] old_names <- names(...future.oldEnvVars)
[21:39:06.014] envs <- base::Sys.getenv()
[21:39:06.014] names <- names(envs)
[21:39:06.014] common <- intersect(names, old_names)
[21:39:06.014] added <- setdiff(names, old_names)
[21:39:06.014] removed <- setdiff(old_names, names)
[21:39:06.014] changed <- common[...future.oldEnvVars[common] !=
[21:39:06.014] envs[common]]
[21:39:06.014] NAMES <- toupper(changed)
[21:39:06.014] args <- list()
[21:39:06.014] for (kk in seq_along(NAMES)) {
[21:39:06.014] name <- changed[[kk]]
[21:39:06.014] NAME <- NAMES[[kk]]
[21:39:06.014] if (name != NAME && is.element(NAME, old_names))
[21:39:06.014] next
[21:39:06.014] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:06.014] }
[21:39:06.014] NAMES <- toupper(added)
[21:39:06.014] for (kk in seq_along(NAMES)) {
[21:39:06.014] name <- added[[kk]]
[21:39:06.014] NAME <- NAMES[[kk]]
[21:39:06.014] if (name != NAME && is.element(NAME, old_names))
[21:39:06.014] next
[21:39:06.014] args[[name]] <- ""
[21:39:06.014] }
[21:39:06.014] NAMES <- toupper(removed)
[21:39:06.014] for (kk in seq_along(NAMES)) {
[21:39:06.014] name <- removed[[kk]]
[21:39:06.014] NAME <- NAMES[[kk]]
[21:39:06.014] if (name != NAME && is.element(NAME, old_names))
[21:39:06.014] next
[21:39:06.014] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:06.014] }
[21:39:06.014] if (length(args) > 0)
[21:39:06.014] base::do.call(base::Sys.setenv, args = args)
[21:39:06.014] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:06.014] }
[21:39:06.014] else {
[21:39:06.014] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:06.014] }
[21:39:06.014] {
[21:39:06.014] if (base::length(...future.futureOptionsAdded) >
[21:39:06.014] 0L) {
[21:39:06.014] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:06.014] base::names(opts) <- ...future.futureOptionsAdded
[21:39:06.014] base::options(opts)
[21:39:06.014] }
[21:39:06.014] {
[21:39:06.014] {
[21:39:06.014] NULL
[21:39:06.014] RNGkind("Mersenne-Twister")
[21:39:06.014] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:06.014] inherits = FALSE)
[21:39:06.014] }
[21:39:06.014] options(future.plan = NULL)
[21:39:06.014] if (is.na(NA_character_))
[21:39:06.014] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:06.014] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:06.014] future::plan(list(function (..., workers = availableCores(constraints = "multicore"),
[21:39:06.014] envir = parent.frame())
[21:39:06.014] {
[21:39:06.014] default_workers <- missing(workers)
[21:39:06.014] if (is.function(workers))
[21:39:06.014] workers <- workers()
[21:39:06.014] workers <- structure(as.integer(workers),
[21:39:06.014] class = class(workers))
[21:39:06.014] stop_if_not(is.finite(workers), workers >=
[21:39:06.014] 1L)
[21:39:06.014] if ((workers == 1L && !inherits(workers,
[21:39:06.014] "AsIs")) || !supportsMulticore(warn = TRUE)) {
[21:39:06.014] if (default_workers)
[21:39:06.014] supportsMulticore(warn = TRUE)
[21:39:06.014] return(sequential(..., envir = envir))
[21:39:06.014] }
[21:39:06.014] oopts <- options(mc.cores = workers)
[21:39:06.014] on.exit(options(oopts))
[21:39:06.014] future <- MulticoreFuture(..., workers = workers,
[21:39:06.014] envir = envir)
[21:39:06.014] if (!future$lazy)
[21:39:06.014] future <- run(future)
[21:39:06.014] invisible(future)
[21:39:06.014] }), .cleanup = FALSE, .init = FALSE)
[21:39:06.014] }
[21:39:06.014] }
[21:39:06.014] }
[21:39:06.014] })
[21:39:06.014] if (TRUE) {
[21:39:06.014] base::sink(type = "output", split = FALSE)
[21:39:06.014] if (TRUE) {
[21:39:06.014] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:06.014] }
[21:39:06.014] else {
[21:39:06.014] ...future.result["stdout"] <- base::list(NULL)
[21:39:06.014] }
[21:39:06.014] base::close(...future.stdout)
[21:39:06.014] ...future.stdout <- NULL
[21:39:06.014] }
[21:39:06.014] ...future.result$conditions <- ...future.conditions
[21:39:06.014] ...future.result$finished <- base::Sys.time()
[21:39:06.014] ...future.result
[21:39:06.014] }
[21:39:06.018] assign_globals() ...
[21:39:06.018] List of 5
[21:39:06.018] $ ...future.FUN :function (x)
[21:39:06.018] $ future.call.arguments : list()
[21:39:06.018] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:06.018] $ ...future.elements_ii :List of 2
[21:39:06.018] ..$ : int 1
[21:39:06.018] ..$ : int 0
[21:39:06.018] $ ...future.seeds_ii : NULL
[21:39:06.018] $ ...future.globals.maxSize: NULL
[21:39:06.018] - attr(*, "resolved")= logi FALSE
[21:39:06.018] - attr(*, "total_size")= num 4720
[21:39:06.018] - attr(*, "where")=List of 5
[21:39:06.018] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:06.018] ..$ future.call.arguments :<environment: R_EmptyEnv>
[21:39:06.018] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:06.018] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:06.018] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:06.018] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:06.018] - attr(*, "already-done")= logi TRUE
[21:39:06.042] - reassign environment for '...future.FUN'
[21:39:06.042] - copied '...future.FUN' to environment
[21:39:06.043] - copied 'future.call.arguments' to environment
[21:39:06.043] - copied '...future.elements_ii' to environment
[21:39:06.043] - copied '...future.seeds_ii' to environment
[21:39:06.043] - copied '...future.globals.maxSize' to environment
[21:39:06.044] assign_globals() ... done
[21:39:06.044] plan(): Setting new future strategy stack:
[21:39:06.044] List of future strategies:
[21:39:06.044] 1. sequential:
[21:39:06.044] - args: function (..., envir = parent.frame())
[21:39:06.044] - tweaked: FALSE
[21:39:06.044] - call: NULL
[21:39:06.045] plan(): nbrOfWorkers() = 1
[21:39:06.547] plan(): Setting new future strategy stack:
[21:39:06.548] List of future strategies:
[21:39:06.548] 1. multicore:
[21:39:06.548] - args: function (..., workers = availableCores(constraints = "multicore"), envir = parent.frame())
[21:39:06.548] - tweaked: FALSE
[21:39:06.548] - call: plan(strategy)
[21:39:06.574] plan(): nbrOfWorkers() = 1
[21:39:06.574] SequentialFuture started (and completed)
[21:39:06.574] - Launch lazy future ... done
[21:39:06.575] run() for 'SequentialFuture' ... done
[21:39:06.575] Created future:
[21:39:06.575] SequentialFuture:
[21:39:06.575] Label: 'future_lapply-1'
[21:39:06.575] Expression:
[21:39:06.575] {
[21:39:06.575] do.call(function(...) {
[21:39:06.575] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:06.575] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:06.575] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:06.575] on.exit(options(oopts), add = TRUE)
[21:39:06.575] }
[21:39:06.575] {
[21:39:06.575] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:06.575] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:06.575] ...future.FUN(...future.X_jj, ...)
[21:39:06.575] })
[21:39:06.575] }
[21:39:06.575] }, args = future.call.arguments)
[21:39:06.575] }
[21:39:06.575] Lazy evaluation: FALSE
[21:39:06.575] Asynchronous evaluation: FALSE
[21:39:06.575] Local evaluation: TRUE
[21:39:06.575] Environment: R_GlobalEnv
[21:39:06.575] Capture standard output: TRUE
[21:39:06.575] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:06.575] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:06.575] Packages: <none>
[21:39:06.575] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:06.575] Resolved: TRUE
[21:39:06.575] Value: 112 bytes of class 'list'
[21:39:06.575] Early signaling: FALSE
[21:39:06.575] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:06.575] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:06.577] Chunk #1 of 1 ... DONE
[21:39:06.577] Launching 1 futures (chunks) ... DONE
[21:39:06.578] Resolving 1 futures (chunks) ...
[21:39:06.578] resolve() on list ...
[21:39:06.578] recursive: 0
[21:39:06.578] length: 1
[21:39:06.578]
[21:39:06.579] resolved() for 'SequentialFuture' ...
[21:39:06.579] - state: 'finished'
[21:39:06.579] - run: TRUE
[21:39:06.579] - result: 'FutureResult'
[21:39:06.579] resolved() for 'SequentialFuture' ... done
[21:39:06.580] Future #1
[21:39:06.580] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:06.580] - nx: 1
[21:39:06.580] - relay: TRUE
[21:39:06.581] - stdout: TRUE
[21:39:06.581] - signal: TRUE
[21:39:06.581] - resignal: FALSE
[21:39:06.581] - force: TRUE
[21:39:06.581] - relayed: [n=1] FALSE
[21:39:06.582] - queued futures: [n=1] FALSE
[21:39:06.582] - until=1
[21:39:06.582] - relaying element #1
[21:39:06.582] - relayed: [n=1] TRUE
[21:39:06.583] - queued futures: [n=1] TRUE
[21:39:06.583] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:06.583] length: 0 (resolved future 1)
[21:39:06.583] Relaying remaining futures
[21:39:06.583] signalConditionsASAP(NULL, pos=0) ...
[21:39:06.584] - nx: 1
[21:39:06.584] - relay: TRUE
[21:39:06.584] - stdout: TRUE
[21:39:06.584] - signal: TRUE
[21:39:06.584] - resignal: FALSE
[21:39:06.585] - force: TRUE
[21:39:06.585] - relayed: [n=1] TRUE
[21:39:06.600] - queued futures: [n=1] TRUE
- flush all
[21:39:06.601] - relayed: [n=1] TRUE
[21:39:06.601] - queued futures: [n=1] TRUE
[21:39:06.601] signalConditionsASAP(NULL, pos=0) ... done
[21:39:06.601] resolve() on list ... DONE
[21:39:06.602] - Number of value chunks collected: 1
[21:39:06.602] Resolving 1 futures (chunks) ... DONE
[21:39:06.602] Reducing values from 1 chunks ...
[21:39:06.602] - Number of values collected after concatenation: 2
[21:39:06.603] - Number of values expected: 2
[21:39:06.603] Reducing values from 1 chunks ... DONE
[21:39:06.603] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ... DONE
* future_lapply(x, ..., future.stdout = NA) ...
[21:39:06.604] future_lapply() ...
[21:39:06.638] Number of chunks: 1
[21:39:06.638] getGlobalsAndPackagesXApply() ...
[21:39:06.638] - future.globals: TRUE
[21:39:06.638] getGlobalsAndPackages() ...
[21:39:06.639] Searching for globals...
[21:39:06.642] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[21:39:06.642] Searching for globals ... DONE
[21:39:06.643] Resolving globals: FALSE
[21:39:06.643] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[21:39:06.644] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[21:39:06.644] - globals: [1] 'FUN'
[21:39:06.645]
[21:39:06.645] getGlobalsAndPackages() ... DONE
[21:39:06.645] - globals found/used: [n=1] 'FUN'
[21:39:06.645] - needed namespaces: [n=0]
[21:39:06.646] Finding globals ... DONE
[21:39:06.646] - use_args: TRUE
[21:39:06.646] - Getting '...' globals ...
[21:39:06.647] resolve() on list ...
[21:39:06.647] recursive: 0
[21:39:06.647] length: 1
[21:39:06.647] elements: '...'
[21:39:06.648] length: 0 (resolved future 1)
[21:39:06.648] resolve() on list ... DONE
[21:39:06.648] - '...' content: [n=0]
[21:39:06.648] List of 1
[21:39:06.648] $ ...: list()
[21:39:06.648] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:06.648] - attr(*, "where")=List of 1
[21:39:06.648] ..$ ...:<environment: 0x55c1ee780d28>
[21:39:06.648] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:06.648] - attr(*, "resolved")= logi TRUE
[21:39:06.648] - attr(*, "total_size")= num NA
[21:39:06.671] - Getting '...' globals ... DONE
[21:39:06.671] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[21:39:06.671] List of 2
[21:39:06.671] $ ...future.FUN:function (x)
[21:39:06.671] $ ... : list()
[21:39:06.671] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:06.671] - attr(*, "where")=List of 2
[21:39:06.671] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:06.671] ..$ ... :<environment: 0x55c1ee780d28>
[21:39:06.671] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:06.671] - attr(*, "resolved")= logi FALSE
[21:39:06.671] - attr(*, "total_size")= num 4720
[21:39:06.678] Packages to be attached in all futures: [n=0]
[21:39:06.678] getGlobalsAndPackagesXApply() ... DONE
[21:39:06.679] Number of futures (= number of chunks): 1
[21:39:06.679] Launching 1 futures (chunks) ...
[21:39:06.679] Chunk #1 of 1 ...
[21:39:06.679] - Finding globals in 'X' for chunk #1 ...
[21:39:06.680] getGlobalsAndPackages() ...
[21:39:06.680] Searching for globals...
[21:39:06.680]
[21:39:06.681] Searching for globals ... DONE
[21:39:06.681] - globals: [0] <none>
[21:39:06.681] getGlobalsAndPackages() ... DONE
[21:39:06.681] + additional globals found: [n=0]
[21:39:06.682] + additional namespaces needed: [n=0]
[21:39:06.682] - Finding globals in 'X' for chunk #1 ... DONE
[21:39:06.682] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:06.682] - seeds: <none>
[21:39:06.699] getGlobalsAndPackages() ...
[21:39:06.699] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:06.699] Resolving globals: FALSE
[21:39:06.699] Tweak future expression to call with '...' arguments ...
[21:39:06.700] {
[21:39:06.700] do.call(function(...) {
[21:39:06.700] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:06.700] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:06.700] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:06.700] on.exit(options(oopts), add = TRUE)
[21:39:06.700] }
[21:39:06.700] {
[21:39:06.700] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:06.700] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:06.700] ...future.FUN(...future.X_jj, ...)
[21:39:06.700] })
[21:39:06.700] }
[21:39:06.700] }, args = future.call.arguments)
[21:39:06.700] }
[21:39:06.700] Tweak future expression to call with '...' arguments ... DONE
[21:39:06.701] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:06.701]
[21:39:06.702] getGlobalsAndPackages() ... DONE
[21:39:06.702] run() for 'Future' ...
[21:39:06.702] - state: 'created'
[21:39:06.703] - Future backend: 'FutureStrategy', 'multicore', 'multiprocess', 'future', 'function'
[21:39:06.766] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:06.766] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:06.766] - Field: 'label'
[21:39:06.767] - Field: 'local'
[21:39:06.767] - Field: 'owner'
[21:39:06.767] - Field: 'envir'
[21:39:06.767] - Field: 'packages'
[21:39:06.767] - Field: 'gc'
[21:39:06.768] - Field: 'conditions'
[21:39:06.768] - Field: 'expr'
[21:39:06.768] - Field: 'uuid'
[21:39:06.768] - Field: 'seed'
[21:39:06.768] - Field: 'version'
[21:39:06.769] - Field: 'result'
[21:39:06.769] - Field: 'asynchronous'
[21:39:06.769] - Field: 'calls'
[21:39:06.769] - Field: 'globals'
[21:39:06.769] - Field: 'stdout'
[21:39:06.770] - Field: 'earlySignal'
[21:39:06.773] - Field: 'lazy'
[21:39:06.773] - Field: 'state'
[21:39:06.773] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:06.774] - Launch lazy future ...
[21:39:06.774] Packages needed by the future expression (n = 0): <none>
[21:39:06.774] Packages needed by future strategies (n = 0): <none>
[21:39:06.775] {
[21:39:06.775] {
[21:39:06.775] {
[21:39:06.775] ...future.startTime <- base::Sys.time()
[21:39:06.775] {
[21:39:06.775] {
[21:39:06.775] {
[21:39:06.775] base::local({
[21:39:06.775] has_future <- base::requireNamespace("future",
[21:39:06.775] quietly = TRUE)
[21:39:06.775] if (has_future) {
[21:39:06.775] ns <- base::getNamespace("future")
[21:39:06.775] version <- ns[[".package"]][["version"]]
[21:39:06.775] if (is.null(version))
[21:39:06.775] version <- utils::packageVersion("future")
[21:39:06.775] }
[21:39:06.775] else {
[21:39:06.775] version <- NULL
[21:39:06.775] }
[21:39:06.775] if (!has_future || version < "1.8.0") {
[21:39:06.775] info <- base::c(r_version = base::gsub("R version ",
[21:39:06.775] "", base::R.version$version.string),
[21:39:06.775] platform = base::sprintf("%s (%s-bit)",
[21:39:06.775] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:06.775] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:06.775] "release", "version")], collapse = " "),
[21:39:06.775] hostname = base::Sys.info()[["nodename"]])
[21:39:06.775] info <- base::sprintf("%s: %s", base::names(info),
[21:39:06.775] info)
[21:39:06.775] info <- base::paste(info, collapse = "; ")
[21:39:06.775] if (!has_future) {
[21:39:06.775] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:06.775] info)
[21:39:06.775] }
[21:39:06.775] else {
[21:39:06.775] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:06.775] info, version)
[21:39:06.775] }
[21:39:06.775] base::stop(msg)
[21:39:06.775] }
[21:39:06.775] })
[21:39:06.775] }
[21:39:06.775] options(future.plan = NULL)
[21:39:06.775] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:06.775] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:06.775] }
[21:39:06.775] ...future.workdir <- getwd()
[21:39:06.775] }
[21:39:06.775] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:06.775] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:06.775] }
[21:39:06.775] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:06.775] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:06.775] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:06.775] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:06.775] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:06.775] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:06.775] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:06.775] base::names(...future.oldOptions))
[21:39:06.775] }
[21:39:06.775] if (TRUE) {
[21:39:06.775] }
[21:39:06.775] else {
[21:39:06.775] if (NA) {
[21:39:06.775] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:06.775] open = "w")
[21:39:06.775] }
[21:39:06.775] else {
[21:39:06.775] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:06.775] windows = "NUL", "/dev/null"), open = "w")
[21:39:06.775] }
[21:39:06.775] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:06.775] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:06.775] base::sink(type = "output", split = FALSE)
[21:39:06.775] base::close(...future.stdout)
[21:39:06.775] }, add = TRUE)
[21:39:06.775] }
[21:39:06.775] ...future.frame <- base::sys.nframe()
[21:39:06.775] ...future.conditions <- base::list()
[21:39:06.775] ...future.rng <- base::globalenv()$.Random.seed
[21:39:06.775] if (FALSE) {
[21:39:06.775] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:06.775] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:06.775] }
[21:39:06.775] ...future.result <- base::tryCatch({
[21:39:06.775] base::withCallingHandlers({
[21:39:06.775] ...future.value <- base::withVisible(base::local({
[21:39:06.775] do.call(function(...) {
[21:39:06.775] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:06.775] if (!identical(...future.globals.maxSize.org,
[21:39:06.775] ...future.globals.maxSize)) {
[21:39:06.775] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:06.775] on.exit(options(oopts), add = TRUE)
[21:39:06.775] }
[21:39:06.775] {
[21:39:06.775] lapply(seq_along(...future.elements_ii),
[21:39:06.775] FUN = function(jj) {
[21:39:06.775] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:06.775] ...future.FUN(...future.X_jj, ...)
[21:39:06.775] })
[21:39:06.775] }
[21:39:06.775] }, args = future.call.arguments)
[21:39:06.775] }))
[21:39:06.775] future::FutureResult(value = ...future.value$value,
[21:39:06.775] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:06.775] ...future.rng), globalenv = if (FALSE)
[21:39:06.775] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:06.775] ...future.globalenv.names))
[21:39:06.775] else NULL, started = ...future.startTime, version = "1.8")
[21:39:06.775] }, condition = base::local({
[21:39:06.775] c <- base::c
[21:39:06.775] inherits <- base::inherits
[21:39:06.775] invokeRestart <- base::invokeRestart
[21:39:06.775] length <- base::length
[21:39:06.775] list <- base::list
[21:39:06.775] seq.int <- base::seq.int
[21:39:06.775] signalCondition <- base::signalCondition
[21:39:06.775] sys.calls <- base::sys.calls
[21:39:06.775] `[[` <- base::`[[`
[21:39:06.775] `+` <- base::`+`
[21:39:06.775] `<<-` <- base::`<<-`
[21:39:06.775] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:06.775] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:06.775] 3L)]
[21:39:06.775] }
[21:39:06.775] function(cond) {
[21:39:06.775] is_error <- inherits(cond, "error")
[21:39:06.775] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:06.775] NULL)
[21:39:06.775] if (is_error) {
[21:39:06.775] sessionInformation <- function() {
[21:39:06.775] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:06.775] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:06.775] search = base::search(), system = base::Sys.info())
[21:39:06.775] }
[21:39:06.775] ...future.conditions[[length(...future.conditions) +
[21:39:06.775] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:06.775] cond$call), session = sessionInformation(),
[21:39:06.775] timestamp = base::Sys.time(), signaled = 0L)
[21:39:06.775] signalCondition(cond)
[21:39:06.775] }
[21:39:06.775] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:06.775] "immediateCondition"))) {
[21:39:06.775] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:06.775] ...future.conditions[[length(...future.conditions) +
[21:39:06.775] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:06.775] if (TRUE && !signal) {
[21:39:06.775] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:06.775] {
[21:39:06.775] inherits <- base::inherits
[21:39:06.775] invokeRestart <- base::invokeRestart
[21:39:06.775] is.null <- base::is.null
[21:39:06.775] muffled <- FALSE
[21:39:06.775] if (inherits(cond, "message")) {
[21:39:06.775] muffled <- grepl(pattern, "muffleMessage")
[21:39:06.775] if (muffled)
[21:39:06.775] invokeRestart("muffleMessage")
[21:39:06.775] }
[21:39:06.775] else if (inherits(cond, "warning")) {
[21:39:06.775] muffled <- grepl(pattern, "muffleWarning")
[21:39:06.775] if (muffled)
[21:39:06.775] invokeRestart("muffleWarning")
[21:39:06.775] }
[21:39:06.775] else if (inherits(cond, "condition")) {
[21:39:06.775] if (!is.null(pattern)) {
[21:39:06.775] computeRestarts <- base::computeRestarts
[21:39:06.775] grepl <- base::grepl
[21:39:06.775] restarts <- computeRestarts(cond)
[21:39:06.775] for (restart in restarts) {
[21:39:06.775] name <- restart$name
[21:39:06.775] if (is.null(name))
[21:39:06.775] next
[21:39:06.775] if (!grepl(pattern, name))
[21:39:06.775] next
[21:39:06.775] invokeRestart(restart)
[21:39:06.775] muffled <- TRUE
[21:39:06.775] break
[21:39:06.775] }
[21:39:06.775] }
[21:39:06.775] }
[21:39:06.775] invisible(muffled)
[21:39:06.775] }
[21:39:06.775] muffleCondition(cond, pattern = "^muffle")
[21:39:06.775] }
[21:39:06.775] }
[21:39:06.775] else {
[21:39:06.775] if (TRUE) {
[21:39:06.775] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:06.775] {
[21:39:06.775] inherits <- base::inherits
[21:39:06.775] invokeRestart <- base::invokeRestart
[21:39:06.775] is.null <- base::is.null
[21:39:06.775] muffled <- FALSE
[21:39:06.775] if (inherits(cond, "message")) {
[21:39:06.775] muffled <- grepl(pattern, "muffleMessage")
[21:39:06.775] if (muffled)
[21:39:06.775] invokeRestart("muffleMessage")
[21:39:06.775] }
[21:39:06.775] else if (inherits(cond, "warning")) {
[21:39:06.775] muffled <- grepl(pattern, "muffleWarning")
[21:39:06.775] if (muffled)
[21:39:06.775] invokeRestart("muffleWarning")
[21:39:06.775] }
[21:39:06.775] else if (inherits(cond, "condition")) {
[21:39:06.775] if (!is.null(pattern)) {
[21:39:06.775] computeRestarts <- base::computeRestarts
[21:39:06.775] grepl <- base::grepl
[21:39:06.775] restarts <- computeRestarts(cond)
[21:39:06.775] for (restart in restarts) {
[21:39:06.775] name <- restart$name
[21:39:06.775] if (is.null(name))
[21:39:06.775] next
[21:39:06.775] if (!grepl(pattern, name))
[21:39:06.775] next
[21:39:06.775] invokeRestart(restart)
[21:39:06.775] muffled <- TRUE
[21:39:06.775] break
[21:39:06.775] }
[21:39:06.775] }
[21:39:06.775] }
[21:39:06.775] invisible(muffled)
[21:39:06.775] }
[21:39:06.775] muffleCondition(cond, pattern = "^muffle")
[21:39:06.775] }
[21:39:06.775] }
[21:39:06.775] }
[21:39:06.775] }))
[21:39:06.775] }, error = function(ex) {
[21:39:06.775] base::structure(base::list(value = NULL, visible = NULL,
[21:39:06.775] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:06.775] ...future.rng), started = ...future.startTime,
[21:39:06.775] finished = Sys.time(), session_uuid = NA_character_,
[21:39:06.775] version = "1.8"), class = "FutureResult")
[21:39:06.775] }, finally = {
[21:39:06.775] if (!identical(...future.workdir, getwd()))
[21:39:06.775] setwd(...future.workdir)
[21:39:06.775] {
[21:39:06.775] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:06.775] ...future.oldOptions$nwarnings <- NULL
[21:39:06.775] }
[21:39:06.775] base::options(...future.oldOptions)
[21:39:06.775] if (.Platform$OS.type == "windows") {
[21:39:06.775] old_names <- names(...future.oldEnvVars)
[21:39:06.775] envs <- base::Sys.getenv()
[21:39:06.775] names <- names(envs)
[21:39:06.775] common <- intersect(names, old_names)
[21:39:06.775] added <- setdiff(names, old_names)
[21:39:06.775] removed <- setdiff(old_names, names)
[21:39:06.775] changed <- common[...future.oldEnvVars[common] !=
[21:39:06.775] envs[common]]
[21:39:06.775] NAMES <- toupper(changed)
[21:39:06.775] args <- list()
[21:39:06.775] for (kk in seq_along(NAMES)) {
[21:39:06.775] name <- changed[[kk]]
[21:39:06.775] NAME <- NAMES[[kk]]
[21:39:06.775] if (name != NAME && is.element(NAME, old_names))
[21:39:06.775] next
[21:39:06.775] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:06.775] }
[21:39:06.775] NAMES <- toupper(added)
[21:39:06.775] for (kk in seq_along(NAMES)) {
[21:39:06.775] name <- added[[kk]]
[21:39:06.775] NAME <- NAMES[[kk]]
[21:39:06.775] if (name != NAME && is.element(NAME, old_names))
[21:39:06.775] next
[21:39:06.775] args[[name]] <- ""
[21:39:06.775] }
[21:39:06.775] NAMES <- toupper(removed)
[21:39:06.775] for (kk in seq_along(NAMES)) {
[21:39:06.775] name <- removed[[kk]]
[21:39:06.775] NAME <- NAMES[[kk]]
[21:39:06.775] if (name != NAME && is.element(NAME, old_names))
[21:39:06.775] next
[21:39:06.775] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:06.775] }
[21:39:06.775] if (length(args) > 0)
[21:39:06.775] base::do.call(base::Sys.setenv, args = args)
[21:39:06.775] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:06.775] }
[21:39:06.775] else {
[21:39:06.775] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:06.775] }
[21:39:06.775] {
[21:39:06.775] if (base::length(...future.futureOptionsAdded) >
[21:39:06.775] 0L) {
[21:39:06.775] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:06.775] base::names(opts) <- ...future.futureOptionsAdded
[21:39:06.775] base::options(opts)
[21:39:06.775] }
[21:39:06.775] {
[21:39:06.775] {
[21:39:06.775] NULL
[21:39:06.775] RNGkind("Mersenne-Twister")
[21:39:06.775] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:06.775] inherits = FALSE)
[21:39:06.775] }
[21:39:06.775] options(future.plan = NULL)
[21:39:06.775] if (is.na(NA_character_))
[21:39:06.775] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:06.775] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:06.775] future::plan(list(function (..., workers = availableCores(constraints = "multicore"),
[21:39:06.775] envir = parent.frame())
[21:39:06.775] {
[21:39:06.775] default_workers <- missing(workers)
[21:39:06.775] if (is.function(workers))
[21:39:06.775] workers <- workers()
[21:39:06.775] workers <- structure(as.integer(workers),
[21:39:06.775] class = class(workers))
[21:39:06.775] stop_if_not(is.finite(workers), workers >=
[21:39:06.775] 1L)
[21:39:06.775] if ((workers == 1L && !inherits(workers,
[21:39:06.775] "AsIs")) || !supportsMulticore(warn = TRUE)) {
[21:39:06.775] if (default_workers)
[21:39:06.775] supportsMulticore(warn = TRUE)
[21:39:06.775] return(sequential(..., envir = envir))
[21:39:06.775] }
[21:39:06.775] oopts <- options(mc.cores = workers)
[21:39:06.775] on.exit(options(oopts))
[21:39:06.775] future <- MulticoreFuture(..., workers = workers,
[21:39:06.775] envir = envir)
[21:39:06.775] if (!future$lazy)
[21:39:06.775] future <- run(future)
[21:39:06.775] invisible(future)
[21:39:06.775] }), .cleanup = FALSE, .init = FALSE)
[21:39:06.775] }
[21:39:06.775] }
[21:39:06.775] }
[21:39:06.775] })
[21:39:06.775] if (FALSE) {
[21:39:06.775] base::sink(type = "output", split = FALSE)
[21:39:06.775] if (NA) {
[21:39:06.775] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:06.775] }
[21:39:06.775] else {
[21:39:06.775] ...future.result["stdout"] <- base::list(NULL)
[21:39:06.775] }
[21:39:06.775] base::close(...future.stdout)
[21:39:06.775] ...future.stdout <- NULL
[21:39:06.775] }
[21:39:06.775] ...future.result$conditions <- ...future.conditions
[21:39:06.775] ...future.result$finished <- base::Sys.time()
[21:39:06.775] ...future.result
[21:39:06.775] }
[21:39:06.795] assign_globals() ...
[21:39:06.795] List of 5
[21:39:06.795] $ ...future.FUN :function (x)
[21:39:06.795] $ future.call.arguments : list()
[21:39:06.795] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:06.795] $ ...future.elements_ii :List of 2
[21:39:06.795] ..$ : int 1
[21:39:06.795] ..$ : int 0
[21:39:06.795] $ ...future.seeds_ii : NULL
[21:39:06.795] $ ...future.globals.maxSize: NULL
[21:39:06.795] - attr(*, "resolved")= logi FALSE
[21:39:06.795] - attr(*, "total_size")= num 4720
[21:39:06.795] - attr(*, "where")=List of 5
[21:39:06.795] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:06.795] ..$ future.call.arguments :<environment: R_EmptyEnv>
[21:39:06.795] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:06.795] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:06.795] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:06.795] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:06.795] - attr(*, "already-done")= logi TRUE
[21:39:06.806] - reassign environment for '...future.FUN'
[21:39:06.806] - copied '...future.FUN' to environment
[21:39:06.806] - copied 'future.call.arguments' to environment
[21:39:06.806] - copied '...future.elements_ii' to environment
[21:39:06.807] - copied '...future.seeds_ii' to environment
[21:39:06.807] - copied '...future.globals.maxSize' to environment
[21:39:06.807] assign_globals() ... done
[21:39:06.808] plan(): Setting new future strategy stack:
[21:39:06.808] List of future strategies:
[21:39:06.808] 1. sequential:
[21:39:06.808] - args: function (..., envir = parent.frame())
[21:39:06.808] - tweaked: FALSE
[21:39:06.808] - call: NULL
[21:39:06.809] plan(): nbrOfWorkers() = 1
[21:39:07.311] plan(): Setting new future strategy stack:
[21:39:07.311] List of future strategies:
[21:39:07.311] 1. multicore:
[21:39:07.311] - args: function (..., workers = availableCores(constraints = "multicore"), envir = parent.frame())
[21:39:07.311] - tweaked: FALSE
[21:39:07.311] - call: plan(strategy)
[21:39:07.343] plan(): nbrOfWorkers() = 1
[21:39:07.343] SequentialFuture started (and completed)
[21:39:07.344] - Launch lazy future ... done
[21:39:07.344] run() for 'SequentialFuture' ... done
[21:39:07.344] Created future:
[21:39:07.344] SequentialFuture:
[21:39:07.344] Label: 'future_lapply-1'
[21:39:07.344] Expression:
[21:39:07.344] {
[21:39:07.344] do.call(function(...) {
[21:39:07.344] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:07.344] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:07.344] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:07.344] on.exit(options(oopts), add = TRUE)
[21:39:07.344] }
[21:39:07.344] {
[21:39:07.344] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:07.344] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:07.344] ...future.FUN(...future.X_jj, ...)
[21:39:07.344] })
[21:39:07.344] }
[21:39:07.344] }, args = future.call.arguments)
[21:39:07.344] }
[21:39:07.344] Lazy evaluation: FALSE
[21:39:07.344] Asynchronous evaluation: FALSE
[21:39:07.344] Local evaluation: TRUE
[21:39:07.344] Environment: R_GlobalEnv
[21:39:07.344] Capture standard output: NA
[21:39:07.344] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:07.344] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:07.344] Packages: <none>
[21:39:07.344] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:07.344] Resolved: TRUE
[21:39:07.344] Value: 112 bytes of class 'list'
[21:39:07.344] Early signaling: FALSE
[21:39:07.344] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:07.344] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:07.346] Chunk #1 of 1 ... DONE
[21:39:07.347] Launching 1 futures (chunks) ... DONE
[21:39:07.347] Resolving 1 futures (chunks) ...
[21:39:07.347] resolve() on list ...
[21:39:07.347] recursive: 0
[21:39:07.348] length: 1
[21:39:07.348]
[21:39:07.348] resolved() for 'SequentialFuture' ...
[21:39:07.348] - state: 'finished'
[21:39:07.348] - run: TRUE
[21:39:07.349] - result: 'FutureResult'
[21:39:07.349] resolved() for 'SequentialFuture' ... done
[21:39:07.349] Future #1
[21:39:07.349] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:07.350] - nx: 1
[21:39:07.350] - relay: TRUE
[21:39:07.350] - stdout: TRUE
[21:39:07.350] - signal: TRUE
[21:39:07.350] - resignal: FALSE
[21:39:07.351] - force: TRUE
[21:39:07.351] - relayed: [n=1] FALSE
[21:39:07.351] - queued futures: [n=1] FALSE
[21:39:07.351] - until=1
[21:39:07.351] - relaying element #1
[21:39:07.352] - relayed: [n=1] TRUE
[21:39:07.352] - queued futures: [n=1] TRUE
[21:39:07.352] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:07.352] length: 0 (resolved future 1)
[21:39:07.353] Relaying remaining futures
[21:39:07.353] signalConditionsASAP(NULL, pos=0) ...
[21:39:07.353] - nx: 1
[21:39:07.353] - relay: TRUE
[21:39:07.353] - stdout: TRUE
[21:39:07.354] - signal: TRUE
[21:39:07.354] - resignal: FALSE
[21:39:07.354] - force: TRUE
[21:39:07.354] - relayed: [n=1] TRUE
[21:39:07.354] - queued futures: [n=1] TRUE
- flush all
[21:39:07.367] - relayed: [n=1] TRUE
[21:39:07.367] - queued futures: [n=1] TRUE
[21:39:07.367] signalConditionsASAP(NULL, pos=0) ... done
[21:39:07.368] resolve() on list ... DONE
[21:39:07.368] - Number of value chunks collected: 1
[21:39:07.368] Resolving 1 futures (chunks) ... DONE
[21:39:07.368] Reducing values from 1 chunks ...
[21:39:07.369] - Number of values collected after concatenation: 2
[21:39:07.369] - Number of values expected: 2
[21:39:07.369] Reducing values from 1 chunks ... DONE
[21:39:07.369] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = NA) ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ...
[21:39:07.370] future_mapply() ...
[21:39:07.411] Number of chunks: 1
[21:39:07.411] getGlobalsAndPackagesXApply() ...
[21:39:07.411] - future.globals: TRUE
[21:39:07.412] getGlobalsAndPackages() ...
[21:39:07.412] Searching for globals...
[21:39:07.415] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[21:39:07.415] Searching for globals ... DONE
[21:39:07.416] Resolving globals: FALSE
[21:39:07.420] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[21:39:07.421] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[21:39:07.421] - globals: [1] 'FUN'
[21:39:07.421]
[21:39:07.421] getGlobalsAndPackages() ... DONE
[21:39:07.422] - globals found/used: [n=1] 'FUN'
[21:39:07.422] - needed namespaces: [n=0]
[21:39:07.422] Finding globals ... DONE
[21:39:07.422] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[21:39:07.431] List of 2
[21:39:07.431] $ ...future.FUN:function (x, y)
[21:39:07.431] $ MoreArgs : NULL
[21:39:07.431] - attr(*, "where")=List of 2
[21:39:07.431] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:07.431] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:07.431] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:07.431] - attr(*, "resolved")= logi FALSE
[21:39:07.431] - attr(*, "total_size")= num NA
[21:39:07.436] Packages to be attached in all futures: [n=0]
[21:39:07.437] getGlobalsAndPackagesXApply() ... DONE
[21:39:07.437] Number of futures (= number of chunks): 1
[21:39:07.437] Launching 1 futures (chunks) ...
[21:39:07.438] Chunk #1 of 1 ...
[21:39:07.438] - Finding globals in '...' for chunk #1 ...
[21:39:07.438] getGlobalsAndPackages() ...
[21:39:07.438] Searching for globals...
[21:39:07.439]
[21:39:07.439] Searching for globals ... DONE
[21:39:07.440] - globals: [0] <none>
[21:39:07.440] getGlobalsAndPackages() ... DONE
[21:39:07.440] + additional globals found: [n=0]
[21:39:07.440] + additional namespaces needed: [n=0]
[21:39:07.441] - Finding globals in '...' for chunk #1 ... DONE
[21:39:07.441] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:07.441] - seeds: <none>
[21:39:07.441] getGlobalsAndPackages() ...
[21:39:07.442] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:07.442] Resolving globals: FALSE
[21:39:07.467] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[21:39:07.468] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[21:39:07.469] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:07.469]
[21:39:07.469] getGlobalsAndPackages() ... DONE
[21:39:07.470] run() for 'Future' ...
[21:39:07.470] - state: 'created'
[21:39:07.470] - Future backend: 'FutureStrategy', 'multicore', 'multiprocess', 'future', 'function'
[21:39:07.497] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:07.498] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:07.498] - Field: 'label'
[21:39:07.498] - Field: 'local'
[21:39:07.499] - Field: 'owner'
[21:39:07.499] - Field: 'envir'
[21:39:07.499] - Field: 'packages'
[21:39:07.499] - Field: 'gc'
[21:39:07.500] - Field: 'conditions'
[21:39:07.500] - Field: 'expr'
[21:39:07.500] - Field: 'uuid'
[21:39:07.500] - Field: 'seed'
[21:39:07.501] - Field: 'version'
[21:39:07.501] - Field: 'result'
[21:39:07.501] - Field: 'asynchronous'
[21:39:07.501] - Field: 'calls'
[21:39:07.501] - Field: 'globals'
[21:39:07.502] - Field: 'stdout'
[21:39:07.502] - Field: 'earlySignal'
[21:39:07.502] - Field: 'lazy'
[21:39:07.502] - Field: 'state'
[21:39:07.503] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:07.503] - Launch lazy future ...
[21:39:07.503] Packages needed by the future expression (n = 0): <none>
[21:39:07.504] Packages needed by future strategies (n = 0): <none>
[21:39:07.505] {
[21:39:07.505] {
[21:39:07.505] {
[21:39:07.505] ...future.startTime <- base::Sys.time()
[21:39:07.505] {
[21:39:07.505] {
[21:39:07.505] {
[21:39:07.505] base::local({
[21:39:07.505] has_future <- base::requireNamespace("future",
[21:39:07.505] quietly = TRUE)
[21:39:07.505] if (has_future) {
[21:39:07.505] ns <- base::getNamespace("future")
[21:39:07.505] version <- ns[[".package"]][["version"]]
[21:39:07.505] if (is.null(version))
[21:39:07.505] version <- utils::packageVersion("future")
[21:39:07.505] }
[21:39:07.505] else {
[21:39:07.505] version <- NULL
[21:39:07.505] }
[21:39:07.505] if (!has_future || version < "1.8.0") {
[21:39:07.505] info <- base::c(r_version = base::gsub("R version ",
[21:39:07.505] "", base::R.version$version.string),
[21:39:07.505] platform = base::sprintf("%s (%s-bit)",
[21:39:07.505] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:07.505] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:07.505] "release", "version")], collapse = " "),
[21:39:07.505] hostname = base::Sys.info()[["nodename"]])
[21:39:07.505] info <- base::sprintf("%s: %s", base::names(info),
[21:39:07.505] info)
[21:39:07.505] info <- base::paste(info, collapse = "; ")
[21:39:07.505] if (!has_future) {
[21:39:07.505] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:07.505] info)
[21:39:07.505] }
[21:39:07.505] else {
[21:39:07.505] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:07.505] info, version)
[21:39:07.505] }
[21:39:07.505] base::stop(msg)
[21:39:07.505] }
[21:39:07.505] })
[21:39:07.505] }
[21:39:07.505] options(future.plan = NULL)
[21:39:07.505] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:07.505] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:07.505] }
[21:39:07.505] ...future.workdir <- getwd()
[21:39:07.505] }
[21:39:07.505] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:07.505] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:07.505] }
[21:39:07.505] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:07.505] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:07.505] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:07.505] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:07.505] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:07.505] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:07.505] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:07.505] base::names(...future.oldOptions))
[21:39:07.505] }
[21:39:07.505] if (FALSE) {
[21:39:07.505] }
[21:39:07.505] else {
[21:39:07.505] if (FALSE) {
[21:39:07.505] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:07.505] open = "w")
[21:39:07.505] }
[21:39:07.505] else {
[21:39:07.505] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:07.505] windows = "NUL", "/dev/null"), open = "w")
[21:39:07.505] }
[21:39:07.505] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:07.505] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:07.505] base::sink(type = "output", split = FALSE)
[21:39:07.505] base::close(...future.stdout)
[21:39:07.505] }, add = TRUE)
[21:39:07.505] }
[21:39:07.505] ...future.frame <- base::sys.nframe()
[21:39:07.505] ...future.conditions <- base::list()
[21:39:07.505] ...future.rng <- base::globalenv()$.Random.seed
[21:39:07.505] if (FALSE) {
[21:39:07.505] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:07.505] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:07.505] }
[21:39:07.505] ...future.result <- base::tryCatch({
[21:39:07.505] base::withCallingHandlers({
[21:39:07.505] ...future.value <- base::withVisible(base::local({
[21:39:07.505] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:07.505] if (!identical(...future.globals.maxSize.org,
[21:39:07.505] ...future.globals.maxSize)) {
[21:39:07.505] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:07.505] on.exit(options(oopts), add = TRUE)
[21:39:07.505] }
[21:39:07.505] {
[21:39:07.505] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:07.505] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE,
[21:39:07.505] USE.NAMES = FALSE)
[21:39:07.505] do.call(mapply, args = args)
[21:39:07.505] }
[21:39:07.505] }))
[21:39:07.505] future::FutureResult(value = ...future.value$value,
[21:39:07.505] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:07.505] ...future.rng), globalenv = if (FALSE)
[21:39:07.505] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:07.505] ...future.globalenv.names))
[21:39:07.505] else NULL, started = ...future.startTime, version = "1.8")
[21:39:07.505] }, condition = base::local({
[21:39:07.505] c <- base::c
[21:39:07.505] inherits <- base::inherits
[21:39:07.505] invokeRestart <- base::invokeRestart
[21:39:07.505] length <- base::length
[21:39:07.505] list <- base::list
[21:39:07.505] seq.int <- base::seq.int
[21:39:07.505] signalCondition <- base::signalCondition
[21:39:07.505] sys.calls <- base::sys.calls
[21:39:07.505] `[[` <- base::`[[`
[21:39:07.505] `+` <- base::`+`
[21:39:07.505] `<<-` <- base::`<<-`
[21:39:07.505] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:07.505] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:07.505] 3L)]
[21:39:07.505] }
[21:39:07.505] function(cond) {
[21:39:07.505] is_error <- inherits(cond, "error")
[21:39:07.505] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:07.505] NULL)
[21:39:07.505] if (is_error) {
[21:39:07.505] sessionInformation <- function() {
[21:39:07.505] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:07.505] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:07.505] search = base::search(), system = base::Sys.info())
[21:39:07.505] }
[21:39:07.505] ...future.conditions[[length(...future.conditions) +
[21:39:07.505] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:07.505] cond$call), session = sessionInformation(),
[21:39:07.505] timestamp = base::Sys.time(), signaled = 0L)
[21:39:07.505] signalCondition(cond)
[21:39:07.505] }
[21:39:07.505] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:07.505] "immediateCondition"))) {
[21:39:07.505] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:07.505] ...future.conditions[[length(...future.conditions) +
[21:39:07.505] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:07.505] if (TRUE && !signal) {
[21:39:07.505] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:07.505] {
[21:39:07.505] inherits <- base::inherits
[21:39:07.505] invokeRestart <- base::invokeRestart
[21:39:07.505] is.null <- base::is.null
[21:39:07.505] muffled <- FALSE
[21:39:07.505] if (inherits(cond, "message")) {
[21:39:07.505] muffled <- grepl(pattern, "muffleMessage")
[21:39:07.505] if (muffled)
[21:39:07.505] invokeRestart("muffleMessage")
[21:39:07.505] }
[21:39:07.505] else if (inherits(cond, "warning")) {
[21:39:07.505] muffled <- grepl(pattern, "muffleWarning")
[21:39:07.505] if (muffled)
[21:39:07.505] invokeRestart("muffleWarning")
[21:39:07.505] }
[21:39:07.505] else if (inherits(cond, "condition")) {
[21:39:07.505] if (!is.null(pattern)) {
[21:39:07.505] computeRestarts <- base::computeRestarts
[21:39:07.505] grepl <- base::grepl
[21:39:07.505] restarts <- computeRestarts(cond)
[21:39:07.505] for (restart in restarts) {
[21:39:07.505] name <- restart$name
[21:39:07.505] if (is.null(name))
[21:39:07.505] next
[21:39:07.505] if (!grepl(pattern, name))
[21:39:07.505] next
[21:39:07.505] invokeRestart(restart)
[21:39:07.505] muffled <- TRUE
[21:39:07.505] break
[21:39:07.505] }
[21:39:07.505] }
[21:39:07.505] }
[21:39:07.505] invisible(muffled)
[21:39:07.505] }
[21:39:07.505] muffleCondition(cond, pattern = "^muffle")
[21:39:07.505] }
[21:39:07.505] }
[21:39:07.505] else {
[21:39:07.505] if (TRUE) {
[21:39:07.505] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:07.505] {
[21:39:07.505] inherits <- base::inherits
[21:39:07.505] invokeRestart <- base::invokeRestart
[21:39:07.505] is.null <- base::is.null
[21:39:07.505] muffled <- FALSE
[21:39:07.505] if (inherits(cond, "message")) {
[21:39:07.505] muffled <- grepl(pattern, "muffleMessage")
[21:39:07.505] if (muffled)
[21:39:07.505] invokeRestart("muffleMessage")
[21:39:07.505] }
[21:39:07.505] else if (inherits(cond, "warning")) {
[21:39:07.505] muffled <- grepl(pattern, "muffleWarning")
[21:39:07.505] if (muffled)
[21:39:07.505] invokeRestart("muffleWarning")
[21:39:07.505] }
[21:39:07.505] else if (inherits(cond, "condition")) {
[21:39:07.505] if (!is.null(pattern)) {
[21:39:07.505] computeRestarts <- base::computeRestarts
[21:39:07.505] grepl <- base::grepl
[21:39:07.505] restarts <- computeRestarts(cond)
[21:39:07.505] for (restart in restarts) {
[21:39:07.505] name <- restart$name
[21:39:07.505] if (is.null(name))
[21:39:07.505] next
[21:39:07.505] if (!grepl(pattern, name))
[21:39:07.505] next
[21:39:07.505] invokeRestart(restart)
[21:39:07.505] muffled <- TRUE
[21:39:07.505] break
[21:39:07.505] }
[21:39:07.505] }
[21:39:07.505] }
[21:39:07.505] invisible(muffled)
[21:39:07.505] }
[21:39:07.505] muffleCondition(cond, pattern = "^muffle")
[21:39:07.505] }
[21:39:07.505] }
[21:39:07.505] }
[21:39:07.505] }))
[21:39:07.505] }, error = function(ex) {
[21:39:07.505] base::structure(base::list(value = NULL, visible = NULL,
[21:39:07.505] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:07.505] ...future.rng), started = ...future.startTime,
[21:39:07.505] finished = Sys.time(), session_uuid = NA_character_,
[21:39:07.505] version = "1.8"), class = "FutureResult")
[21:39:07.505] }, finally = {
[21:39:07.505] if (!identical(...future.workdir, getwd()))
[21:39:07.505] setwd(...future.workdir)
[21:39:07.505] {
[21:39:07.505] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:07.505] ...future.oldOptions$nwarnings <- NULL
[21:39:07.505] }
[21:39:07.505] base::options(...future.oldOptions)
[21:39:07.505] if (.Platform$OS.type == "windows") {
[21:39:07.505] old_names <- names(...future.oldEnvVars)
[21:39:07.505] envs <- base::Sys.getenv()
[21:39:07.505] names <- names(envs)
[21:39:07.505] common <- intersect(names, old_names)
[21:39:07.505] added <- setdiff(names, old_names)
[21:39:07.505] removed <- setdiff(old_names, names)
[21:39:07.505] changed <- common[...future.oldEnvVars[common] !=
[21:39:07.505] envs[common]]
[21:39:07.505] NAMES <- toupper(changed)
[21:39:07.505] args <- list()
[21:39:07.505] for (kk in seq_along(NAMES)) {
[21:39:07.505] name <- changed[[kk]]
[21:39:07.505] NAME <- NAMES[[kk]]
[21:39:07.505] if (name != NAME && is.element(NAME, old_names))
[21:39:07.505] next
[21:39:07.505] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:07.505] }
[21:39:07.505] NAMES <- toupper(added)
[21:39:07.505] for (kk in seq_along(NAMES)) {
[21:39:07.505] name <- added[[kk]]
[21:39:07.505] NAME <- NAMES[[kk]]
[21:39:07.505] if (name != NAME && is.element(NAME, old_names))
[21:39:07.505] next
[21:39:07.505] args[[name]] <- ""
[21:39:07.505] }
[21:39:07.505] NAMES <- toupper(removed)
[21:39:07.505] for (kk in seq_along(NAMES)) {
[21:39:07.505] name <- removed[[kk]]
[21:39:07.505] NAME <- NAMES[[kk]]
[21:39:07.505] if (name != NAME && is.element(NAME, old_names))
[21:39:07.505] next
[21:39:07.505] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:07.505] }
[21:39:07.505] if (length(args) > 0)
[21:39:07.505] base::do.call(base::Sys.setenv, args = args)
[21:39:07.505] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:07.505] }
[21:39:07.505] else {
[21:39:07.505] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:07.505] }
[21:39:07.505] {
[21:39:07.505] if (base::length(...future.futureOptionsAdded) >
[21:39:07.505] 0L) {
[21:39:07.505] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:07.505] base::names(opts) <- ...future.futureOptionsAdded
[21:39:07.505] base::options(opts)
[21:39:07.505] }
[21:39:07.505] {
[21:39:07.505] {
[21:39:07.505] NULL
[21:39:07.505] RNGkind("Mersenne-Twister")
[21:39:07.505] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:07.505] inherits = FALSE)
[21:39:07.505] }
[21:39:07.505] options(future.plan = NULL)
[21:39:07.505] if (is.na(NA_character_))
[21:39:07.505] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:07.505] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:07.505] future::plan(list(function (..., workers = availableCores(constraints = "multicore"),
[21:39:07.505] envir = parent.frame())
[21:39:07.505] {
[21:39:07.505] default_workers <- missing(workers)
[21:39:07.505] if (is.function(workers))
[21:39:07.505] workers <- workers()
[21:39:07.505] workers <- structure(as.integer(workers),
[21:39:07.505] class = class(workers))
[21:39:07.505] stop_if_not(is.finite(workers), workers >=
[21:39:07.505] 1L)
[21:39:07.505] if ((workers == 1L && !inherits(workers,
[21:39:07.505] "AsIs")) || !supportsMulticore(warn = TRUE)) {
[21:39:07.505] if (default_workers)
[21:39:07.505] supportsMulticore(warn = TRUE)
[21:39:07.505] return(sequential(..., envir = envir))
[21:39:07.505] }
[21:39:07.505] oopts <- options(mc.cores = workers)
[21:39:07.505] on.exit(options(oopts))
[21:39:07.505] future <- MulticoreFuture(..., workers = workers,
[21:39:07.505] envir = envir)
[21:39:07.505] if (!future$lazy)
[21:39:07.505] future <- run(future)
[21:39:07.505] invisible(future)
[21:39:07.505] }), .cleanup = FALSE, .init = FALSE)
[21:39:07.505] }
[21:39:07.505] }
[21:39:07.505] }
[21:39:07.505] })
[21:39:07.505] if (TRUE) {
[21:39:07.505] base::sink(type = "output", split = FALSE)
[21:39:07.505] if (FALSE) {
[21:39:07.505] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:07.505] }
[21:39:07.505] else {
[21:39:07.505] ...future.result["stdout"] <- base::list(NULL)
[21:39:07.505] }
[21:39:07.505] base::close(...future.stdout)
[21:39:07.505] ...future.stdout <- NULL
[21:39:07.505] }
[21:39:07.505] ...future.result$conditions <- ...future.conditions
[21:39:07.505] ...future.result$finished <- base::Sys.time()
[21:39:07.505] ...future.result
[21:39:07.505] }
[21:39:07.517] assign_globals() ...
[21:39:07.517] List of 5
[21:39:07.517] $ ...future.FUN :function (x, y)
[21:39:07.517] $ MoreArgs : NULL
[21:39:07.517] $ ...future.elements_ii :List of 2
[21:39:07.517] ..$ :List of 2
[21:39:07.517] .. ..$ : int 1
[21:39:07.517] .. ..$ : int 0
[21:39:07.517] ..$ :List of 2
[21:39:07.517] .. ..$ : int 0
[21:39:07.517] .. ..$ : int 1
[21:39:07.517] $ ...future.seeds_ii : NULL
[21:39:07.517] $ ...future.globals.maxSize: NULL
[21:39:07.517] - attr(*, "resolved")= logi FALSE
[21:39:07.517] - attr(*, "total_size")= num 6480
[21:39:07.517] - attr(*, "where")=List of 5
[21:39:07.517] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:07.517] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:07.517] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:07.517] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:07.517] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:07.517] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:07.517] - attr(*, "already-done")= logi TRUE
[21:39:07.543] - reassign environment for '...future.FUN'
[21:39:07.543] - copied '...future.FUN' to environment
[21:39:07.544] - copied 'MoreArgs' to environment
[21:39:07.544] - copied '...future.elements_ii' to environment
[21:39:07.544] - copied '...future.seeds_ii' to environment
[21:39:07.544] - copied '...future.globals.maxSize' to environment
[21:39:07.545] assign_globals() ... done
[21:39:07.545] plan(): Setting new future strategy stack:
[21:39:07.545] List of future strategies:
[21:39:07.545] 1. sequential:
[21:39:07.545] - args: function (..., envir = parent.frame())
[21:39:07.545] - tweaked: FALSE
[21:39:07.545] - call: NULL
[21:39:07.546] plan(): nbrOfWorkers() = 1
[21:39:08.052] plan(): Setting new future strategy stack:
[21:39:08.052] List of future strategies:
[21:39:08.052] 1. multicore:
[21:39:08.052] - args: function (..., workers = availableCores(constraints = "multicore"), envir = parent.frame())
[21:39:08.052] - tweaked: FALSE
[21:39:08.052] - call: plan(strategy)
[21:39:08.078] plan(): nbrOfWorkers() = 1
[21:39:08.078] SequentialFuture started (and completed)
[21:39:08.079] - Launch lazy future ... done
[21:39:08.079] run() for 'SequentialFuture' ... done
[21:39:08.079] Created future:
[21:39:08.079] SequentialFuture:
[21:39:08.079] Label: 'future_mapply-1'
[21:39:08.079] Expression:
[21:39:08.079] {
[21:39:08.079] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:08.079] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:08.079] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:08.079] on.exit(options(oopts), add = TRUE)
[21:39:08.079] }
[21:39:08.079] {
[21:39:08.079] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:08.079] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[21:39:08.079] do.call(mapply, args = args)
[21:39:08.079] }
[21:39:08.079] }
[21:39:08.079] Lazy evaluation: FALSE
[21:39:08.079] Asynchronous evaluation: FALSE
[21:39:08.079] Local evaluation: TRUE
[21:39:08.079] Environment: R_GlobalEnv
[21:39:08.079] Capture standard output: FALSE
[21:39:08.079] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:08.079] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:08.079] Packages: <none>
[21:39:08.079] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:08.079] Resolved: TRUE
[21:39:08.079] Value: 224 bytes of class 'list'
[21:39:08.079] Early signaling: FALSE
[21:39:08.079] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:08.079] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:08.081] Chunk #1 of 1 ... DONE
[21:39:08.082] Launching 1 futures (chunks) ... DONE
[21:39:08.082] Resolving 1 futures (chunks) ...
[21:39:08.082] resolve() on list ...
[21:39:08.082] recursive: 0
[21:39:08.082] length: 1
[21:39:08.083]
[21:39:08.083] resolved() for 'SequentialFuture' ...
[21:39:08.083] - state: 'finished'
[21:39:08.083] - run: TRUE
[21:39:08.083] - result: 'FutureResult'
[21:39:08.084] resolved() for 'SequentialFuture' ... done
[21:39:08.084] Future #1
[21:39:08.084] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:08.084] - nx: 1
[21:39:08.085] - relay: TRUE
[21:39:08.085] - stdout: TRUE
[21:39:08.085] - signal: TRUE
[21:39:08.085] - resignal: FALSE
[21:39:08.085] - force: TRUE
[21:39:08.086] - relayed: [n=1] FALSE
[21:39:08.086] - queued futures: [n=1] FALSE
[21:39:08.086] - until=1
[21:39:08.086] - relaying element #1
[21:39:08.087] - relayed: [n=1] TRUE
[21:39:08.087] - queued futures: [n=1] TRUE
[21:39:08.087] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:08.087] length: 0 (resolved future 1)
[21:39:08.088] Relaying remaining futures
[21:39:08.088] signalConditionsASAP(NULL, pos=0) ...
[21:39:08.088] - nx: 1
[21:39:08.088] - relay: TRUE
[21:39:08.088] - stdout: TRUE
[21:39:08.089] - signal: TRUE
[21:39:08.089] - resignal: FALSE
[21:39:08.089] - force: TRUE
[21:39:08.089] - relayed: [n=1] TRUE
[21:39:08.089] - queued futures: [n=1] TRUE
- flush all
[21:39:08.090] - relayed: [n=1] TRUE
[21:39:08.090] - queued futures: [n=1] TRUE
[21:39:08.090] signalConditionsASAP(NULL, pos=0) ... done
[21:39:08.103] resolve() on list ... DONE
[21:39:08.103] - Number of value chunks collected: 1
[21:39:08.103] Resolving 1 futures (chunks) ... DONE
[21:39:08.104] Reducing values from 1 chunks ...
[21:39:08.104] - Number of values collected after concatenation: 2
[21:39:08.104] - Number of values expected: 2
[21:39:08.104] Reducing values from 1 chunks ... DONE
[21:39:08.104] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ...
[21:39:08.105] future_mapply() ...
[21:39:08.142] Number of chunks: 1
[21:39:08.143] getGlobalsAndPackagesXApply() ...
[21:39:08.143] - future.globals: TRUE
[21:39:08.143] getGlobalsAndPackages() ...
[21:39:08.144] Searching for globals...
[21:39:08.148] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[21:39:08.149] Searching for globals ... DONE
[21:39:08.149] Resolving globals: FALSE
[21:39:08.150] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[21:39:08.151] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[21:39:08.152] - globals: [1] 'FUN'
[21:39:08.152]
[21:39:08.152] getGlobalsAndPackages() ... DONE
[21:39:08.152] - globals found/used: [n=1] 'FUN'
[21:39:08.153] - needed namespaces: [n=0]
[21:39:08.153] Finding globals ... DONE
[21:39:08.154] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[21:39:08.154] List of 2
[21:39:08.154] $ ...future.FUN:function (x, y)
[21:39:08.154] $ MoreArgs : NULL
[21:39:08.154] - attr(*, "where")=List of 2
[21:39:08.154] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:08.154] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:08.154] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:08.154] - attr(*, "resolved")= logi FALSE
[21:39:08.154] - attr(*, "total_size")= num NA
[21:39:08.173] Packages to be attached in all futures: [n=0]
[21:39:08.174] getGlobalsAndPackagesXApply() ... DONE
[21:39:08.174] Number of futures (= number of chunks): 1
[21:39:08.174] Launching 1 futures (chunks) ...
[21:39:08.175] Chunk #1 of 1 ...
[21:39:08.175] - Finding globals in '...' for chunk #1 ...
[21:39:08.175] getGlobalsAndPackages() ...
[21:39:08.176] Searching for globals...
[21:39:08.177]
[21:39:08.177] Searching for globals ... DONE
[21:39:08.177] - globals: [0] <none>
[21:39:08.177] getGlobalsAndPackages() ... DONE
[21:39:08.178] + additional globals found: [n=0]
[21:39:08.178] + additional namespaces needed: [n=0]
[21:39:08.178] - Finding globals in '...' for chunk #1 ... DONE
[21:39:08.195] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:08.195] - seeds: <none>
[21:39:08.196] getGlobalsAndPackages() ...
[21:39:08.196] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:08.196] Resolving globals: FALSE
[21:39:08.198] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[21:39:08.199] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[21:39:08.199] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:08.200]
[21:39:08.200] getGlobalsAndPackages() ... DONE
[21:39:08.201] run() for 'Future' ...
[21:39:08.201] - state: 'created'
[21:39:08.201] - Future backend: 'FutureStrategy', 'multicore', 'multiprocess', 'future', 'function'
[21:39:08.243] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:08.243] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:08.244] - Field: 'label'
[21:39:08.244] - Field: 'local'
[21:39:08.244] - Field: 'owner'
[21:39:08.244] - Field: 'envir'
[21:39:08.245] - Field: 'packages'
[21:39:08.245] - Field: 'gc'
[21:39:08.245] - Field: 'conditions'
[21:39:08.245] - Field: 'expr'
[21:39:08.246] - Field: 'uuid'
[21:39:08.246] - Field: 'seed'
[21:39:08.246] - Field: 'version'
[21:39:08.246] - Field: 'result'
[21:39:08.247] - Field: 'asynchronous'
[21:39:08.247] - Field: 'calls'
[21:39:08.247] - Field: 'globals'
[21:39:08.247] - Field: 'stdout'
[21:39:08.248] - Field: 'earlySignal'
[21:39:08.248] - Field: 'lazy'
[21:39:08.248] - Field: 'state'
[21:39:08.248] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:08.249] - Launch lazy future ...
[21:39:08.249] Packages needed by the future expression (n = 0): <none>
[21:39:08.250] Packages needed by future strategies (n = 0): <none>
[21:39:08.251] {
[21:39:08.251] {
[21:39:08.251] {
[21:39:08.251] ...future.startTime <- base::Sys.time()
[21:39:08.251] {
[21:39:08.251] {
[21:39:08.251] {
[21:39:08.251] base::local({
[21:39:08.251] has_future <- base::requireNamespace("future",
[21:39:08.251] quietly = TRUE)
[21:39:08.251] if (has_future) {
[21:39:08.251] ns <- base::getNamespace("future")
[21:39:08.251] version <- ns[[".package"]][["version"]]
[21:39:08.251] if (is.null(version))
[21:39:08.251] version <- utils::packageVersion("future")
[21:39:08.251] }
[21:39:08.251] else {
[21:39:08.251] version <- NULL
[21:39:08.251] }
[21:39:08.251] if (!has_future || version < "1.8.0") {
[21:39:08.251] info <- base::c(r_version = base::gsub("R version ",
[21:39:08.251] "", base::R.version$version.string),
[21:39:08.251] platform = base::sprintf("%s (%s-bit)",
[21:39:08.251] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:08.251] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:08.251] "release", "version")], collapse = " "),
[21:39:08.251] hostname = base::Sys.info()[["nodename"]])
[21:39:08.251] info <- base::sprintf("%s: %s", base::names(info),
[21:39:08.251] info)
[21:39:08.251] info <- base::paste(info, collapse = "; ")
[21:39:08.251] if (!has_future) {
[21:39:08.251] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:08.251] info)
[21:39:08.251] }
[21:39:08.251] else {
[21:39:08.251] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:08.251] info, version)
[21:39:08.251] }
[21:39:08.251] base::stop(msg)
[21:39:08.251] }
[21:39:08.251] })
[21:39:08.251] }
[21:39:08.251] options(future.plan = NULL)
[21:39:08.251] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:08.251] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:08.251] }
[21:39:08.251] ...future.workdir <- getwd()
[21:39:08.251] }
[21:39:08.251] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:08.251] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:08.251] }
[21:39:08.251] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:08.251] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:08.251] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:08.251] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:08.251] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:08.251] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:08.251] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:08.251] base::names(...future.oldOptions))
[21:39:08.251] }
[21:39:08.251] if (FALSE) {
[21:39:08.251] }
[21:39:08.251] else {
[21:39:08.251] if (TRUE) {
[21:39:08.251] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:08.251] open = "w")
[21:39:08.251] }
[21:39:08.251] else {
[21:39:08.251] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:08.251] windows = "NUL", "/dev/null"), open = "w")
[21:39:08.251] }
[21:39:08.251] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:08.251] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:08.251] base::sink(type = "output", split = FALSE)
[21:39:08.251] base::close(...future.stdout)
[21:39:08.251] }, add = TRUE)
[21:39:08.251] }
[21:39:08.251] ...future.frame <- base::sys.nframe()
[21:39:08.251] ...future.conditions <- base::list()
[21:39:08.251] ...future.rng <- base::globalenv()$.Random.seed
[21:39:08.251] if (FALSE) {
[21:39:08.251] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:08.251] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:08.251] }
[21:39:08.251] ...future.result <- base::tryCatch({
[21:39:08.251] base::withCallingHandlers({
[21:39:08.251] ...future.value <- base::withVisible(base::local({
[21:39:08.251] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:08.251] if (!identical(...future.globals.maxSize.org,
[21:39:08.251] ...future.globals.maxSize)) {
[21:39:08.251] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:08.251] on.exit(options(oopts), add = TRUE)
[21:39:08.251] }
[21:39:08.251] {
[21:39:08.251] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:08.251] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE,
[21:39:08.251] USE.NAMES = FALSE)
[21:39:08.251] do.call(mapply, args = args)
[21:39:08.251] }
[21:39:08.251] }))
[21:39:08.251] future::FutureResult(value = ...future.value$value,
[21:39:08.251] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:08.251] ...future.rng), globalenv = if (FALSE)
[21:39:08.251] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:08.251] ...future.globalenv.names))
[21:39:08.251] else NULL, started = ...future.startTime, version = "1.8")
[21:39:08.251] }, condition = base::local({
[21:39:08.251] c <- base::c
[21:39:08.251] inherits <- base::inherits
[21:39:08.251] invokeRestart <- base::invokeRestart
[21:39:08.251] length <- base::length
[21:39:08.251] list <- base::list
[21:39:08.251] seq.int <- base::seq.int
[21:39:08.251] signalCondition <- base::signalCondition
[21:39:08.251] sys.calls <- base::sys.calls
[21:39:08.251] `[[` <- base::`[[`
[21:39:08.251] `+` <- base::`+`
[21:39:08.251] `<<-` <- base::`<<-`
[21:39:08.251] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:08.251] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:08.251] 3L)]
[21:39:08.251] }
[21:39:08.251] function(cond) {
[21:39:08.251] is_error <- inherits(cond, "error")
[21:39:08.251] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:08.251] NULL)
[21:39:08.251] if (is_error) {
[21:39:08.251] sessionInformation <- function() {
[21:39:08.251] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:08.251] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:08.251] search = base::search(), system = base::Sys.info())
[21:39:08.251] }
[21:39:08.251] ...future.conditions[[length(...future.conditions) +
[21:39:08.251] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:08.251] cond$call), session = sessionInformation(),
[21:39:08.251] timestamp = base::Sys.time(), signaled = 0L)
[21:39:08.251] signalCondition(cond)
[21:39:08.251] }
[21:39:08.251] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:08.251] "immediateCondition"))) {
[21:39:08.251] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:08.251] ...future.conditions[[length(...future.conditions) +
[21:39:08.251] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:08.251] if (TRUE && !signal) {
[21:39:08.251] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:08.251] {
[21:39:08.251] inherits <- base::inherits
[21:39:08.251] invokeRestart <- base::invokeRestart
[21:39:08.251] is.null <- base::is.null
[21:39:08.251] muffled <- FALSE
[21:39:08.251] if (inherits(cond, "message")) {
[21:39:08.251] muffled <- grepl(pattern, "muffleMessage")
[21:39:08.251] if (muffled)
[21:39:08.251] invokeRestart("muffleMessage")
[21:39:08.251] }
[21:39:08.251] else if (inherits(cond, "warning")) {
[21:39:08.251] muffled <- grepl(pattern, "muffleWarning")
[21:39:08.251] if (muffled)
[21:39:08.251] invokeRestart("muffleWarning")
[21:39:08.251] }
[21:39:08.251] else if (inherits(cond, "condition")) {
[21:39:08.251] if (!is.null(pattern)) {
[21:39:08.251] computeRestarts <- base::computeRestarts
[21:39:08.251] grepl <- base::grepl
[21:39:08.251] restarts <- computeRestarts(cond)
[21:39:08.251] for (restart in restarts) {
[21:39:08.251] name <- restart$name
[21:39:08.251] if (is.null(name))
[21:39:08.251] next
[21:39:08.251] if (!grepl(pattern, name))
[21:39:08.251] next
[21:39:08.251] invokeRestart(restart)
[21:39:08.251] muffled <- TRUE
[21:39:08.251] break
[21:39:08.251] }
[21:39:08.251] }
[21:39:08.251] }
[21:39:08.251] invisible(muffled)
[21:39:08.251] }
[21:39:08.251] muffleCondition(cond, pattern = "^muffle")
[21:39:08.251] }
[21:39:08.251] }
[21:39:08.251] else {
[21:39:08.251] if (TRUE) {
[21:39:08.251] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:08.251] {
[21:39:08.251] inherits <- base::inherits
[21:39:08.251] invokeRestart <- base::invokeRestart
[21:39:08.251] is.null <- base::is.null
[21:39:08.251] muffled <- FALSE
[21:39:08.251] if (inherits(cond, "message")) {
[21:39:08.251] muffled <- grepl(pattern, "muffleMessage")
[21:39:08.251] if (muffled)
[21:39:08.251] invokeRestart("muffleMessage")
[21:39:08.251] }
[21:39:08.251] else if (inherits(cond, "warning")) {
[21:39:08.251] muffled <- grepl(pattern, "muffleWarning")
[21:39:08.251] if (muffled)
[21:39:08.251] invokeRestart("muffleWarning")
[21:39:08.251] }
[21:39:08.251] else if (inherits(cond, "condition")) {
[21:39:08.251] if (!is.null(pattern)) {
[21:39:08.251] computeRestarts <- base::computeRestarts
[21:39:08.251] grepl <- base::grepl
[21:39:08.251] restarts <- computeRestarts(cond)
[21:39:08.251] for (restart in restarts) {
[21:39:08.251] name <- restart$name
[21:39:08.251] if (is.null(name))
[21:39:08.251] next
[21:39:08.251] if (!grepl(pattern, name))
[21:39:08.251] next
[21:39:08.251] invokeRestart(restart)
[21:39:08.251] muffled <- TRUE
[21:39:08.251] break
[21:39:08.251] }
[21:39:08.251] }
[21:39:08.251] }
[21:39:08.251] invisible(muffled)
[21:39:08.251] }
[21:39:08.251] muffleCondition(cond, pattern = "^muffle")
[21:39:08.251] }
[21:39:08.251] }
[21:39:08.251] }
[21:39:08.251] }))
[21:39:08.251] }, error = function(ex) {
[21:39:08.251] base::structure(base::list(value = NULL, visible = NULL,
[21:39:08.251] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:08.251] ...future.rng), started = ...future.startTime,
[21:39:08.251] finished = Sys.time(), session_uuid = NA_character_,
[21:39:08.251] version = "1.8"), class = "FutureResult")
[21:39:08.251] }, finally = {
[21:39:08.251] if (!identical(...future.workdir, getwd()))
[21:39:08.251] setwd(...future.workdir)
[21:39:08.251] {
[21:39:08.251] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:08.251] ...future.oldOptions$nwarnings <- NULL
[21:39:08.251] }
[21:39:08.251] base::options(...future.oldOptions)
[21:39:08.251] if (.Platform$OS.type == "windows") {
[21:39:08.251] old_names <- names(...future.oldEnvVars)
[21:39:08.251] envs <- base::Sys.getenv()
[21:39:08.251] names <- names(envs)
[21:39:08.251] common <- intersect(names, old_names)
[21:39:08.251] added <- setdiff(names, old_names)
[21:39:08.251] removed <- setdiff(old_names, names)
[21:39:08.251] changed <- common[...future.oldEnvVars[common] !=
[21:39:08.251] envs[common]]
[21:39:08.251] NAMES <- toupper(changed)
[21:39:08.251] args <- list()
[21:39:08.251] for (kk in seq_along(NAMES)) {
[21:39:08.251] name <- changed[[kk]]
[21:39:08.251] NAME <- NAMES[[kk]]
[21:39:08.251] if (name != NAME && is.element(NAME, old_names))
[21:39:08.251] next
[21:39:08.251] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:08.251] }
[21:39:08.251] NAMES <- toupper(added)
[21:39:08.251] for (kk in seq_along(NAMES)) {
[21:39:08.251] name <- added[[kk]]
[21:39:08.251] NAME <- NAMES[[kk]]
[21:39:08.251] if (name != NAME && is.element(NAME, old_names))
[21:39:08.251] next
[21:39:08.251] args[[name]] <- ""
[21:39:08.251] }
[21:39:08.251] NAMES <- toupper(removed)
[21:39:08.251] for (kk in seq_along(NAMES)) {
[21:39:08.251] name <- removed[[kk]]
[21:39:08.251] NAME <- NAMES[[kk]]
[21:39:08.251] if (name != NAME && is.element(NAME, old_names))
[21:39:08.251] next
[21:39:08.251] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:08.251] }
[21:39:08.251] if (length(args) > 0)
[21:39:08.251] base::do.call(base::Sys.setenv, args = args)
[21:39:08.251] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:08.251] }
[21:39:08.251] else {
[21:39:08.251] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:08.251] }
[21:39:08.251] {
[21:39:08.251] if (base::length(...future.futureOptionsAdded) >
[21:39:08.251] 0L) {
[21:39:08.251] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:08.251] base::names(opts) <- ...future.futureOptionsAdded
[21:39:08.251] base::options(opts)
[21:39:08.251] }
[21:39:08.251] {
[21:39:08.251] {
[21:39:08.251] NULL
[21:39:08.251] RNGkind("Mersenne-Twister")
[21:39:08.251] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:08.251] inherits = FALSE)
[21:39:08.251] }
[21:39:08.251] options(future.plan = NULL)
[21:39:08.251] if (is.na(NA_character_))
[21:39:08.251] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:08.251] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:08.251] future::plan(list(function (..., workers = availableCores(constraints = "multicore"),
[21:39:08.251] envir = parent.frame())
[21:39:08.251] {
[21:39:08.251] default_workers <- missing(workers)
[21:39:08.251] if (is.function(workers))
[21:39:08.251] workers <- workers()
[21:39:08.251] workers <- structure(as.integer(workers),
[21:39:08.251] class = class(workers))
[21:39:08.251] stop_if_not(is.finite(workers), workers >=
[21:39:08.251] 1L)
[21:39:08.251] if ((workers == 1L && !inherits(workers,
[21:39:08.251] "AsIs")) || !supportsMulticore(warn = TRUE)) {
[21:39:08.251] if (default_workers)
[21:39:08.251] supportsMulticore(warn = TRUE)
[21:39:08.251] return(sequential(..., envir = envir))
[21:39:08.251] }
[21:39:08.251] oopts <- options(mc.cores = workers)
[21:39:08.251] on.exit(options(oopts))
[21:39:08.251] future <- MulticoreFuture(..., workers = workers,
[21:39:08.251] envir = envir)
[21:39:08.251] if (!future$lazy)
[21:39:08.251] future <- run(future)
[21:39:08.251] invisible(future)
[21:39:08.251] }), .cleanup = FALSE, .init = FALSE)
[21:39:08.251] }
[21:39:08.251] }
[21:39:08.251] }
[21:39:08.251] })
[21:39:08.251] if (TRUE) {
[21:39:08.251] base::sink(type = "output", split = FALSE)
[21:39:08.251] if (TRUE) {
[21:39:08.251] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:08.251] }
[21:39:08.251] else {
[21:39:08.251] ...future.result["stdout"] <- base::list(NULL)
[21:39:08.251] }
[21:39:08.251] base::close(...future.stdout)
[21:39:08.251] ...future.stdout <- NULL
[21:39:08.251] }
[21:39:08.251] ...future.result$conditions <- ...future.conditions
[21:39:08.251] ...future.result$finished <- base::Sys.time()
[21:39:08.251] ...future.result
[21:39:08.251] }
[21:39:08.267] assign_globals() ...
[21:39:08.268] List of 5
[21:39:08.268] $ ...future.FUN :function (x, y)
[21:39:08.268] $ MoreArgs : NULL
[21:39:08.268] $ ...future.elements_ii :List of 2
[21:39:08.268] ..$ :List of 2
[21:39:08.268] .. ..$ : int 1
[21:39:08.268] .. ..$ : int 0
[21:39:08.268] ..$ :List of 2
[21:39:08.268] .. ..$ : int 0
[21:39:08.268] .. ..$ : int 1
[21:39:08.268] $ ...future.seeds_ii : NULL
[21:39:08.268] $ ...future.globals.maxSize: NULL
[21:39:08.268] - attr(*, "resolved")= logi FALSE
[21:39:08.268] - attr(*, "total_size")= num 6480
[21:39:08.268] - attr(*, "where")=List of 5
[21:39:08.268] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:08.268] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:08.268] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:08.268] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:08.268] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:08.268] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:08.268] - attr(*, "already-done")= logi TRUE
[21:39:08.300] - reassign environment for '...future.FUN'
[21:39:08.300] - copied '...future.FUN' to environment
[21:39:08.301] - copied 'MoreArgs' to environment
[21:39:08.301] - copied '...future.elements_ii' to environment
[21:39:08.301] - copied '...future.seeds_ii' to environment
[21:39:08.302] - copied '...future.globals.maxSize' to environment
[21:39:08.302] assign_globals() ... done
[21:39:08.303] plan(): Setting new future strategy stack:
[21:39:08.303] List of future strategies:
[21:39:08.303] 1. sequential:
[21:39:08.303] - args: function (..., envir = parent.frame())
[21:39:08.303] - tweaked: FALSE
[21:39:08.303] - call: NULL
[21:39:08.304] plan(): nbrOfWorkers() = 1
[21:39:08.807] plan(): Setting new future strategy stack:
[21:39:08.807] List of future strategies:
[21:39:08.807] 1. multicore:
[21:39:08.807] - args: function (..., workers = availableCores(constraints = "multicore"), envir = parent.frame())
[21:39:08.807] - tweaked: FALSE
[21:39:08.807] - call: plan(strategy)
[21:39:08.838] plan(): nbrOfWorkers() = 1
[21:39:08.839] SequentialFuture started (and completed)
[21:39:08.839] - Launch lazy future ... done
[21:39:08.839] run() for 'SequentialFuture' ... done
[21:39:08.840] Created future:
[21:39:08.840] SequentialFuture:
[21:39:08.840] Label: 'future_mapply-1'
[21:39:08.840] Expression:
[21:39:08.840] {
[21:39:08.840] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:08.840] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:08.840] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:08.840] on.exit(options(oopts), add = TRUE)
[21:39:08.840] }
[21:39:08.840] {
[21:39:08.840] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:08.840] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[21:39:08.840] do.call(mapply, args = args)
[21:39:08.840] }
[21:39:08.840] }
[21:39:08.840] Lazy evaluation: FALSE
[21:39:08.840] Asynchronous evaluation: FALSE
[21:39:08.840] Local evaluation: TRUE
[21:39:08.840] Environment: R_GlobalEnv
[21:39:08.840] Capture standard output: TRUE
[21:39:08.840] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:08.840] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:08.840] Packages: <none>
[21:39:08.840] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:08.840] Resolved: TRUE
[21:39:08.840] Value: 224 bytes of class 'list'
[21:39:08.840] Early signaling: FALSE
[21:39:08.840] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:08.840] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:08.843] Chunk #1 of 1 ... DONE
[21:39:08.843] Launching 1 futures (chunks) ... DONE
[21:39:08.843] Resolving 1 futures (chunks) ...
[21:39:08.844] resolve() on list ...
[21:39:08.844] recursive: 0
[21:39:08.844] length: 1
[21:39:08.844]
[21:39:08.845] resolved() for 'SequentialFuture' ...
[21:39:08.845] - state: 'finished'
[21:39:08.845] - run: TRUE
[21:39:08.845] - result: 'FutureResult'
[21:39:08.846] resolved() for 'SequentialFuture' ... done
[21:39:08.846] Future #1
[21:39:08.846] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:08.847] - nx: 1
[21:39:08.847] - relay: TRUE
[21:39:08.847] - stdout: TRUE
[21:39:08.847] - signal: TRUE
[21:39:08.847] - resignal: FALSE
[21:39:08.848] - force: TRUE
[21:39:08.848] - relayed: [n=1] FALSE
[21:39:08.848] - queued futures: [n=1] FALSE
[21:39:08.848] - until=1
[21:39:08.849] - relaying element #1
[21:39:08.849] - relayed: [n=1] TRUE
[21:39:08.850] - queued futures: [n=1] TRUE
[21:39:08.850] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:08.850] length: 0 (resolved future 1)
[21:39:08.850] Relaying remaining futures
[21:39:08.871] signalConditionsASAP(NULL, pos=0) ...
[21:39:08.871] - nx: 1
[21:39:08.871] - relay: TRUE
[21:39:08.872] - stdout: TRUE
[21:39:08.872] - signal: TRUE
[21:39:08.872] - resignal: FALSE
[21:39:08.872] - force: TRUE
[21:39:08.872] - relayed: [n=1] TRUE
[21:39:08.873] - queued futures: [n=1] TRUE
- flush all
[21:39:08.873] - relayed: [n=1] TRUE
[21:39:08.873] - queued futures: [n=1] TRUE
[21:39:08.874] signalConditionsASAP(NULL, pos=0) ... done
[21:39:08.874] resolve() on list ... DONE
[21:39:08.874] - Number of value chunks collected: 1
[21:39:08.875] Resolving 1 futures (chunks) ... DONE
[21:39:08.875] Reducing values from 1 chunks ...
[21:39:08.875] - Number of values collected after concatenation: 2
[21:39:08.875] - Number of values expected: 2
[21:39:08.999] Reducing values from 1 chunks ... DONE
[21:39:09.000] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ... DONE
* future_mapply(x, ..., future.stdout = NA) ...
[21:39:09.001] future_mapply() ...
[21:39:09.043] Number of chunks: 1
[21:39:09.043] getGlobalsAndPackagesXApply() ...
[21:39:09.043] - future.globals: TRUE
[21:39:09.044] getGlobalsAndPackages() ...
[21:39:09.044] Searching for globals...
[21:39:09.048] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[21:39:09.049] Searching for globals ... DONE
[21:39:09.049] Resolving globals: FALSE
[21:39:09.050] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[21:39:09.051] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[21:39:09.051] - globals: [1] 'FUN'
[21:39:09.052]
[21:39:09.052] getGlobalsAndPackages() ... DONE
[21:39:09.052] - globals found/used: [n=1] 'FUN'
[21:39:09.052] - needed namespaces: [n=0]
[21:39:09.053] Finding globals ... DONE
[21:39:09.053] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[21:39:09.053] List of 2
[21:39:09.053] $ ...future.FUN:function (x, y)
[21:39:09.053] $ MoreArgs : NULL
[21:39:09.053] - attr(*, "where")=List of 2
[21:39:09.053] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:09.053] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:09.053] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:09.053] - attr(*, "resolved")= logi FALSE
[21:39:09.053] - attr(*, "total_size")= num NA
[21:39:09.076] Packages to be attached in all futures: [n=0]
[21:39:09.077] getGlobalsAndPackagesXApply() ... DONE
[21:39:09.077] Number of futures (= number of chunks): 1
[21:39:09.078] Launching 1 futures (chunks) ...
[21:39:09.078] Chunk #1 of 1 ...
[21:39:09.078] - Finding globals in '...' for chunk #1 ...
[21:39:09.078] getGlobalsAndPackages() ...
[21:39:09.079] Searching for globals...
[21:39:09.080]
[21:39:09.080] Searching for globals ... DONE
[21:39:09.080] - globals: [0] <none>
[21:39:09.080] getGlobalsAndPackages() ... DONE
[21:39:09.081] + additional globals found: [n=0]
[21:39:09.081] + additional namespaces needed: [n=0]
[21:39:09.081] - Finding globals in '...' for chunk #1 ... DONE
[21:39:09.082] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:09.082] - seeds: <none>
[21:39:09.082] getGlobalsAndPackages() ...
[21:39:09.082] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:09.083] Resolving globals: FALSE
[21:39:09.084] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[21:39:09.085] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[21:39:09.086] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:09.086]
[21:39:09.086] getGlobalsAndPackages() ... DONE
[21:39:09.103] run() for 'Future' ...
[21:39:09.104] - state: 'created'
[21:39:09.104] - Future backend: 'FutureStrategy', 'multicore', 'multiprocess', 'future', 'function'
[21:39:09.123] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:09.123] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:09.123] - Field: 'label'
[21:39:09.124] - Field: 'local'
[21:39:09.124] - Field: 'owner'
[21:39:09.124] - Field: 'envir'
[21:39:09.124] - Field: 'packages'
[21:39:09.125] - Field: 'gc'
[21:39:09.125] - Field: 'conditions'
[21:39:09.125] - Field: 'expr'
[21:39:09.125] - Field: 'uuid'
[21:39:09.126] - Field: 'seed'
[21:39:09.126] - Field: 'version'
[21:39:09.126] - Field: 'result'
[21:39:09.126] - Field: 'asynchronous'
[21:39:09.127] - Field: 'calls'
[21:39:09.127] - Field: 'globals'
[21:39:09.127] - Field: 'stdout'
[21:39:09.127] - Field: 'earlySignal'
[21:39:09.128] - Field: 'lazy'
[21:39:09.128] - Field: 'state'
[21:39:09.128] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:09.128] - Launch lazy future ...
[21:39:09.129] Packages needed by the future expression (n = 0): <none>
[21:39:09.129] Packages needed by future strategies (n = 0): <none>
[21:39:09.131] {
[21:39:09.131] {
[21:39:09.131] {
[21:39:09.131] ...future.startTime <- base::Sys.time()
[21:39:09.131] {
[21:39:09.131] {
[21:39:09.131] {
[21:39:09.131] base::local({
[21:39:09.131] has_future <- base::requireNamespace("future",
[21:39:09.131] quietly = TRUE)
[21:39:09.131] if (has_future) {
[21:39:09.131] ns <- base::getNamespace("future")
[21:39:09.131] version <- ns[[".package"]][["version"]]
[21:39:09.131] if (is.null(version))
[21:39:09.131] version <- utils::packageVersion("future")
[21:39:09.131] }
[21:39:09.131] else {
[21:39:09.131] version <- NULL
[21:39:09.131] }
[21:39:09.131] if (!has_future || version < "1.8.0") {
[21:39:09.131] info <- base::c(r_version = base::gsub("R version ",
[21:39:09.131] "", base::R.version$version.string),
[21:39:09.131] platform = base::sprintf("%s (%s-bit)",
[21:39:09.131] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:09.131] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:09.131] "release", "version")], collapse = " "),
[21:39:09.131] hostname = base::Sys.info()[["nodename"]])
[21:39:09.131] info <- base::sprintf("%s: %s", base::names(info),
[21:39:09.131] info)
[21:39:09.131] info <- base::paste(info, collapse = "; ")
[21:39:09.131] if (!has_future) {
[21:39:09.131] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:09.131] info)
[21:39:09.131] }
[21:39:09.131] else {
[21:39:09.131] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:09.131] info, version)
[21:39:09.131] }
[21:39:09.131] base::stop(msg)
[21:39:09.131] }
[21:39:09.131] })
[21:39:09.131] }
[21:39:09.131] options(future.plan = NULL)
[21:39:09.131] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:09.131] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:09.131] }
[21:39:09.131] ...future.workdir <- getwd()
[21:39:09.131] }
[21:39:09.131] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:09.131] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:09.131] }
[21:39:09.131] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:09.131] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:09.131] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:09.131] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:09.131] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:09.131] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:09.131] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:09.131] base::names(...future.oldOptions))
[21:39:09.131] }
[21:39:09.131] if (TRUE) {
[21:39:09.131] }
[21:39:09.131] else {
[21:39:09.131] if (NA) {
[21:39:09.131] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:09.131] open = "w")
[21:39:09.131] }
[21:39:09.131] else {
[21:39:09.131] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:09.131] windows = "NUL", "/dev/null"), open = "w")
[21:39:09.131] }
[21:39:09.131] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:09.131] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:09.131] base::sink(type = "output", split = FALSE)
[21:39:09.131] base::close(...future.stdout)
[21:39:09.131] }, add = TRUE)
[21:39:09.131] }
[21:39:09.131] ...future.frame <- base::sys.nframe()
[21:39:09.131] ...future.conditions <- base::list()
[21:39:09.131] ...future.rng <- base::globalenv()$.Random.seed
[21:39:09.131] if (FALSE) {
[21:39:09.131] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:09.131] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:09.131] }
[21:39:09.131] ...future.result <- base::tryCatch({
[21:39:09.131] base::withCallingHandlers({
[21:39:09.131] ...future.value <- base::withVisible(base::local({
[21:39:09.131] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:09.131] if (!identical(...future.globals.maxSize.org,
[21:39:09.131] ...future.globals.maxSize)) {
[21:39:09.131] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:09.131] on.exit(options(oopts), add = TRUE)
[21:39:09.131] }
[21:39:09.131] {
[21:39:09.131] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:09.131] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE,
[21:39:09.131] USE.NAMES = FALSE)
[21:39:09.131] do.call(mapply, args = args)
[21:39:09.131] }
[21:39:09.131] }))
[21:39:09.131] future::FutureResult(value = ...future.value$value,
[21:39:09.131] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:09.131] ...future.rng), globalenv = if (FALSE)
[21:39:09.131] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:09.131] ...future.globalenv.names))
[21:39:09.131] else NULL, started = ...future.startTime, version = "1.8")
[21:39:09.131] }, condition = base::local({
[21:39:09.131] c <- base::c
[21:39:09.131] inherits <- base::inherits
[21:39:09.131] invokeRestart <- base::invokeRestart
[21:39:09.131] length <- base::length
[21:39:09.131] list <- base::list
[21:39:09.131] seq.int <- base::seq.int
[21:39:09.131] signalCondition <- base::signalCondition
[21:39:09.131] sys.calls <- base::sys.calls
[21:39:09.131] `[[` <- base::`[[`
[21:39:09.131] `+` <- base::`+`
[21:39:09.131] `<<-` <- base::`<<-`
[21:39:09.131] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:09.131] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:09.131] 3L)]
[21:39:09.131] }
[21:39:09.131] function(cond) {
[21:39:09.131] is_error <- inherits(cond, "error")
[21:39:09.131] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:09.131] NULL)
[21:39:09.131] if (is_error) {
[21:39:09.131] sessionInformation <- function() {
[21:39:09.131] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:09.131] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:09.131] search = base::search(), system = base::Sys.info())
[21:39:09.131] }
[21:39:09.131] ...future.conditions[[length(...future.conditions) +
[21:39:09.131] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:09.131] cond$call), session = sessionInformation(),
[21:39:09.131] timestamp = base::Sys.time(), signaled = 0L)
[21:39:09.131] signalCondition(cond)
[21:39:09.131] }
[21:39:09.131] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:09.131] "immediateCondition"))) {
[21:39:09.131] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:09.131] ...future.conditions[[length(...future.conditions) +
[21:39:09.131] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:09.131] if (TRUE && !signal) {
[21:39:09.131] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:09.131] {
[21:39:09.131] inherits <- base::inherits
[21:39:09.131] invokeRestart <- base::invokeRestart
[21:39:09.131] is.null <- base::is.null
[21:39:09.131] muffled <- FALSE
[21:39:09.131] if (inherits(cond, "message")) {
[21:39:09.131] muffled <- grepl(pattern, "muffleMessage")
[21:39:09.131] if (muffled)
[21:39:09.131] invokeRestart("muffleMessage")
[21:39:09.131] }
[21:39:09.131] else if (inherits(cond, "warning")) {
[21:39:09.131] muffled <- grepl(pattern, "muffleWarning")
[21:39:09.131] if (muffled)
[21:39:09.131] invokeRestart("muffleWarning")
[21:39:09.131] }
[21:39:09.131] else if (inherits(cond, "condition")) {
[21:39:09.131] if (!is.null(pattern)) {
[21:39:09.131] computeRestarts <- base::computeRestarts
[21:39:09.131] grepl <- base::grepl
[21:39:09.131] restarts <- computeRestarts(cond)
[21:39:09.131] for (restart in restarts) {
[21:39:09.131] name <- restart$name
[21:39:09.131] if (is.null(name))
[21:39:09.131] next
[21:39:09.131] if (!grepl(pattern, name))
[21:39:09.131] next
[21:39:09.131] invokeRestart(restart)
[21:39:09.131] muffled <- TRUE
[21:39:09.131] break
[21:39:09.131] }
[21:39:09.131] }
[21:39:09.131] }
[21:39:09.131] invisible(muffled)
[21:39:09.131] }
[21:39:09.131] muffleCondition(cond, pattern = "^muffle")
[21:39:09.131] }
[21:39:09.131] }
[21:39:09.131] else {
[21:39:09.131] if (TRUE) {
[21:39:09.131] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:09.131] {
[21:39:09.131] inherits <- base::inherits
[21:39:09.131] invokeRestart <- base::invokeRestart
[21:39:09.131] is.null <- base::is.null
[21:39:09.131] muffled <- FALSE
[21:39:09.131] if (inherits(cond, "message")) {
[21:39:09.131] muffled <- grepl(pattern, "muffleMessage")
[21:39:09.131] if (muffled)
[21:39:09.131] invokeRestart("muffleMessage")
[21:39:09.131] }
[21:39:09.131] else if (inherits(cond, "warning")) {
[21:39:09.131] muffled <- grepl(pattern, "muffleWarning")
[21:39:09.131] if (muffled)
[21:39:09.131] invokeRestart("muffleWarning")
[21:39:09.131] }
[21:39:09.131] else if (inherits(cond, "condition")) {
[21:39:09.131] if (!is.null(pattern)) {
[21:39:09.131] computeRestarts <- base::computeRestarts
[21:39:09.131] grepl <- base::grepl
[21:39:09.131] restarts <- computeRestarts(cond)
[21:39:09.131] for (restart in restarts) {
[21:39:09.131] name <- restart$name
[21:39:09.131] if (is.null(name))
[21:39:09.131] next
[21:39:09.131] if (!grepl(pattern, name))
[21:39:09.131] next
[21:39:09.131] invokeRestart(restart)
[21:39:09.131] muffled <- TRUE
[21:39:09.131] break
[21:39:09.131] }
[21:39:09.131] }
[21:39:09.131] }
[21:39:09.131] invisible(muffled)
[21:39:09.131] }
[21:39:09.131] muffleCondition(cond, pattern = "^muffle")
[21:39:09.131] }
[21:39:09.131] }
[21:39:09.131] }
[21:39:09.131] }))
[21:39:09.131] }, error = function(ex) {
[21:39:09.131] base::structure(base::list(value = NULL, visible = NULL,
[21:39:09.131] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:09.131] ...future.rng), started = ...future.startTime,
[21:39:09.131] finished = Sys.time(), session_uuid = NA_character_,
[21:39:09.131] version = "1.8"), class = "FutureResult")
[21:39:09.131] }, finally = {
[21:39:09.131] if (!identical(...future.workdir, getwd()))
[21:39:09.131] setwd(...future.workdir)
[21:39:09.131] {
[21:39:09.131] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:09.131] ...future.oldOptions$nwarnings <- NULL
[21:39:09.131] }
[21:39:09.131] base::options(...future.oldOptions)
[21:39:09.131] if (.Platform$OS.type == "windows") {
[21:39:09.131] old_names <- names(...future.oldEnvVars)
[21:39:09.131] envs <- base::Sys.getenv()
[21:39:09.131] names <- names(envs)
[21:39:09.131] common <- intersect(names, old_names)
[21:39:09.131] added <- setdiff(names, old_names)
[21:39:09.131] removed <- setdiff(old_names, names)
[21:39:09.131] changed <- common[...future.oldEnvVars[common] !=
[21:39:09.131] envs[common]]
[21:39:09.131] NAMES <- toupper(changed)
[21:39:09.131] args <- list()
[21:39:09.131] for (kk in seq_along(NAMES)) {
[21:39:09.131] name <- changed[[kk]]
[21:39:09.131] NAME <- NAMES[[kk]]
[21:39:09.131] if (name != NAME && is.element(NAME, old_names))
[21:39:09.131] next
[21:39:09.131] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:09.131] }
[21:39:09.131] NAMES <- toupper(added)
[21:39:09.131] for (kk in seq_along(NAMES)) {
[21:39:09.131] name <- added[[kk]]
[21:39:09.131] NAME <- NAMES[[kk]]
[21:39:09.131] if (name != NAME && is.element(NAME, old_names))
[21:39:09.131] next
[21:39:09.131] args[[name]] <- ""
[21:39:09.131] }
[21:39:09.131] NAMES <- toupper(removed)
[21:39:09.131] for (kk in seq_along(NAMES)) {
[21:39:09.131] name <- removed[[kk]]
[21:39:09.131] NAME <- NAMES[[kk]]
[21:39:09.131] if (name != NAME && is.element(NAME, old_names))
[21:39:09.131] next
[21:39:09.131] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:09.131] }
[21:39:09.131] if (length(args) > 0)
[21:39:09.131] base::do.call(base::Sys.setenv, args = args)
[21:39:09.131] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:09.131] }
[21:39:09.131] else {
[21:39:09.131] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:09.131] }
[21:39:09.131] {
[21:39:09.131] if (base::length(...future.futureOptionsAdded) >
[21:39:09.131] 0L) {
[21:39:09.131] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:09.131] base::names(opts) <- ...future.futureOptionsAdded
[21:39:09.131] base::options(opts)
[21:39:09.131] }
[21:39:09.131] {
[21:39:09.131] {
[21:39:09.131] NULL
[21:39:09.131] RNGkind("Mersenne-Twister")
[21:39:09.131] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:09.131] inherits = FALSE)
[21:39:09.131] }
[21:39:09.131] options(future.plan = NULL)
[21:39:09.131] if (is.na(NA_character_))
[21:39:09.131] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:09.131] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:09.131] future::plan(list(function (..., workers = availableCores(constraints = "multicore"),
[21:39:09.131] envir = parent.frame())
[21:39:09.131] {
[21:39:09.131] default_workers <- missing(workers)
[21:39:09.131] if (is.function(workers))
[21:39:09.131] workers <- workers()
[21:39:09.131] workers <- structure(as.integer(workers),
[21:39:09.131] class = class(workers))
[21:39:09.131] stop_if_not(is.finite(workers), workers >=
[21:39:09.131] 1L)
[21:39:09.131] if ((workers == 1L && !inherits(workers,
[21:39:09.131] "AsIs")) || !supportsMulticore(warn = TRUE)) {
[21:39:09.131] if (default_workers)
[21:39:09.131] supportsMulticore(warn = TRUE)
[21:39:09.131] return(sequential(..., envir = envir))
[21:39:09.131] }
[21:39:09.131] oopts <- options(mc.cores = workers)
[21:39:09.131] on.exit(options(oopts))
[21:39:09.131] future <- MulticoreFuture(..., workers = workers,
[21:39:09.131] envir = envir)
[21:39:09.131] if (!future$lazy)
[21:39:09.131] future <- run(future)
[21:39:09.131] invisible(future)
[21:39:09.131] }), .cleanup = FALSE, .init = FALSE)
[21:39:09.131] }
[21:39:09.131] }
[21:39:09.131] }
[21:39:09.131] })
[21:39:09.131] if (FALSE) {
[21:39:09.131] base::sink(type = "output", split = FALSE)
[21:39:09.131] if (NA) {
[21:39:09.131] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:09.131] }
[21:39:09.131] else {
[21:39:09.131] ...future.result["stdout"] <- base::list(NULL)
[21:39:09.131] }
[21:39:09.131] base::close(...future.stdout)
[21:39:09.131] ...future.stdout <- NULL
[21:39:09.131] }
[21:39:09.131] ...future.result$conditions <- ...future.conditions
[21:39:09.131] ...future.result$finished <- base::Sys.time()
[21:39:09.131] ...future.result
[21:39:09.131] }
[21:39:09.151] assign_globals() ...
[21:39:09.151] List of 5
[21:39:09.151] $ ...future.FUN :function (x, y)
[21:39:09.151] $ MoreArgs : NULL
[21:39:09.151] $ ...future.elements_ii :List of 2
[21:39:09.151] ..$ :List of 2
[21:39:09.151] .. ..$ : int 1
[21:39:09.151] .. ..$ : int 0
[21:39:09.151] ..$ :List of 2
[21:39:09.151] .. ..$ : int 0
[21:39:09.151] .. ..$ : int 1
[21:39:09.151] $ ...future.seeds_ii : NULL
[21:39:09.151] $ ...future.globals.maxSize: NULL
[21:39:09.151] - attr(*, "resolved")= logi FALSE
[21:39:09.151] - attr(*, "total_size")= num 6480
[21:39:09.151] - attr(*, "where")=List of 5
[21:39:09.151] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:09.151] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:09.151] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:09.151] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:09.151] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:09.151] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:09.151] - attr(*, "already-done")= logi TRUE
[21:39:09.183] - reassign environment for '...future.FUN'
[21:39:09.187] - copied '...future.FUN' to environment
[21:39:09.188] - copied 'MoreArgs' to environment
[21:39:09.188] - copied '...future.elements_ii' to environment
[21:39:09.188] - copied '...future.seeds_ii' to environment
[21:39:09.189] - copied '...future.globals.maxSize' to environment
[21:39:09.189] assign_globals() ... done
[21:39:09.190] plan(): Setting new future strategy stack:
[21:39:09.190] List of future strategies:
[21:39:09.190] 1. sequential:
[21:39:09.190] - args: function (..., envir = parent.frame())
[21:39:09.190] - tweaked: FALSE
[21:39:09.190] - call: NULL
[21:39:09.191] plan(): nbrOfWorkers() = 1
[21:39:09.694] plan(): Setting new future strategy stack:
[21:39:09.694] List of future strategies:
[21:39:09.694] 1. multicore:
[21:39:09.694] - args: function (..., workers = availableCores(constraints = "multicore"), envir = parent.frame())
[21:39:09.694] - tweaked: FALSE
[21:39:09.694] - call: plan(strategy)
[21:39:09.742] plan(): nbrOfWorkers() = 1
[21:39:09.742] SequentialFuture started (and completed)
[21:39:09.743] - Launch lazy future ... done
[21:39:09.743] run() for 'SequentialFuture' ... done
[21:39:09.743] Created future:
[21:39:09.744] SequentialFuture:
[21:39:09.744] Label: 'future_mapply-1'
[21:39:09.744] Expression:
[21:39:09.744] {
[21:39:09.744] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:09.744] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:09.744] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:09.744] on.exit(options(oopts), add = TRUE)
[21:39:09.744] }
[21:39:09.744] {
[21:39:09.744] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:09.744] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[21:39:09.744] do.call(mapply, args = args)
[21:39:09.744] }
[21:39:09.744] }
[21:39:09.744] Lazy evaluation: FALSE
[21:39:09.744] Asynchronous evaluation: FALSE
[21:39:09.744] Local evaluation: TRUE
[21:39:09.744] Environment: R_GlobalEnv
[21:39:09.744] Capture standard output: NA
[21:39:09.744] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:09.744] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:09.744] Packages: <none>
[21:39:09.744] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:09.744] Resolved: TRUE
[21:39:09.744] Value: 224 bytes of class 'list'
[21:39:09.744] Early signaling: FALSE
[21:39:09.744] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:09.744] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:09.746] Chunk #1 of 1 ... DONE
[21:39:09.746] Launching 1 futures (chunks) ... DONE
[21:39:09.747] Resolving 1 futures (chunks) ...
[21:39:09.747] resolve() on list ...
[21:39:09.747] recursive: 0
[21:39:09.747] length: 1
[21:39:09.748]
[21:39:09.748] resolved() for 'SequentialFuture' ...
[21:39:09.748] - state: 'finished'
[21:39:09.748] - run: TRUE
[21:39:09.749] - result: 'FutureResult'
[21:39:09.749] resolved() for 'SequentialFuture' ... done
[21:39:09.749] Future #1
[21:39:09.750] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:09.750] - nx: 1
[21:39:09.750] - relay: TRUE
[21:39:09.750] - stdout: TRUE
[21:39:09.751] - signal: TRUE
[21:39:09.751] - resignal: FALSE
[21:39:09.751] - force: TRUE
[21:39:09.751] - relayed: [n=1] FALSE
[21:39:09.751] - queued futures: [n=1] FALSE
[21:39:09.752] - until=1
[21:39:09.752] - relaying element #1
[21:39:09.752] - relayed: [n=1] TRUE
[21:39:09.753] - queued futures: [n=1] TRUE
[21:39:09.753] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:09.753] length: 0 (resolved future 1)
[21:39:09.753] Relaying remaining futures
[21:39:09.754] signalConditionsASAP(NULL, pos=0) ...
[21:39:09.754] - nx: 1
[21:39:09.754] - relay: TRUE
[21:39:09.754] - stdout: TRUE
[21:39:09.767] - signal: TRUE
[21:39:09.767] - resignal: FALSE
[21:39:09.767] - force: TRUE
[21:39:09.767] - relayed: [n=1] TRUE
[21:39:09.768] - queued futures: [n=1] TRUE
- flush all
[21:39:09.768] - relayed: [n=1] TRUE
[21:39:09.768] - queued futures: [n=1] TRUE
[21:39:09.768] signalConditionsASAP(NULL, pos=0) ... done
[21:39:09.769] resolve() on list ... DONE
[21:39:09.769] - Number of value chunks collected: 1
[21:39:09.769] Resolving 1 futures (chunks) ... DONE
[21:39:09.770] Reducing values from 1 chunks ...
[21:39:09.770] - Number of values collected after concatenation: 2
[21:39:09.770] - Number of values expected: 2
[21:39:09.770] Reducing values from 1 chunks ... DONE
[21:39:09.770] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = NA) ... DONE
* plan('multicore') ... DONE
* plan('multisession') ...
[21:39:09.772] plan(): Setting new future strategy stack:
[21:39:09.772] List of future strategies:
[21:39:09.772] 1. multisession:
[21:39:09.772] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[21:39:09.772] - tweaked: FALSE
[21:39:09.772] - call: plan(strategy)
[21:39:09.773] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[21:39:09.773] multisession:
[21:39:09.773] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[21:39:09.773] - tweaked: FALSE
[21:39:09.773] - call: plan(strategy)
[21:39:09.822] getGlobalsAndPackages() ...
[21:39:09.822] Not searching for globals
[21:39:09.823] - globals: [0] <none>
[21:39:09.823] getGlobalsAndPackages() ... DONE
[21:39:09.824] Packages needed by the future expression (n = 0): <none>
[21:39:09.824] Packages needed by future strategies (n = 0): <none>
[21:39:09.825] {
[21:39:09.825] {
[21:39:09.825] {
[21:39:09.825] ...future.startTime <- base::Sys.time()
[21:39:09.825] {
[21:39:09.825] {
[21:39:09.825] {
[21:39:09.825] base::local({
[21:39:09.825] has_future <- base::requireNamespace("future",
[21:39:09.825] quietly = TRUE)
[21:39:09.825] if (has_future) {
[21:39:09.825] ns <- base::getNamespace("future")
[21:39:09.825] version <- ns[[".package"]][["version"]]
[21:39:09.825] if (is.null(version))
[21:39:09.825] version <- utils::packageVersion("future")
[21:39:09.825] }
[21:39:09.825] else {
[21:39:09.825] version <- NULL
[21:39:09.825] }
[21:39:09.825] if (!has_future || version < "1.8.0") {
[21:39:09.825] info <- base::c(r_version = base::gsub("R version ",
[21:39:09.825] "", base::R.version$version.string),
[21:39:09.825] platform = base::sprintf("%s (%s-bit)",
[21:39:09.825] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:09.825] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:09.825] "release", "version")], collapse = " "),
[21:39:09.825] hostname = base::Sys.info()[["nodename"]])
[21:39:09.825] info <- base::sprintf("%s: %s", base::names(info),
[21:39:09.825] info)
[21:39:09.825] info <- base::paste(info, collapse = "; ")
[21:39:09.825] if (!has_future) {
[21:39:09.825] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:09.825] info)
[21:39:09.825] }
[21:39:09.825] else {
[21:39:09.825] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:09.825] info, version)
[21:39:09.825] }
[21:39:09.825] base::stop(msg)
[21:39:09.825] }
[21:39:09.825] })
[21:39:09.825] }
[21:39:09.825] options(future.plan = NULL)
[21:39:09.825] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:09.825] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:09.825] }
[21:39:09.825] ...future.workdir <- getwd()
[21:39:09.825] }
[21:39:09.825] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:09.825] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:09.825] }
[21:39:09.825] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:09.825] future.globals.maxSize = NULL, future.globals.method = NULL,
[21:39:09.825] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:09.825] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:09.825] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:09.825] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:09.825] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:09.825] base::names(...future.oldOptions))
[21:39:09.825] }
[21:39:09.825] if (FALSE) {
[21:39:09.825] }
[21:39:09.825] else {
[21:39:09.825] if (TRUE) {
[21:39:09.825] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:09.825] open = "w")
[21:39:09.825] }
[21:39:09.825] else {
[21:39:09.825] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:09.825] windows = "NUL", "/dev/null"), open = "w")
[21:39:09.825] }
[21:39:09.825] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:09.825] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:09.825] base::sink(type = "output", split = FALSE)
[21:39:09.825] base::close(...future.stdout)
[21:39:09.825] }, add = TRUE)
[21:39:09.825] }
[21:39:09.825] ...future.frame <- base::sys.nframe()
[21:39:09.825] ...future.conditions <- base::list()
[21:39:09.825] ...future.rng <- base::globalenv()$.Random.seed
[21:39:09.825] if (FALSE) {
[21:39:09.825] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:09.825] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:09.825] }
[21:39:09.825] ...future.result <- base::tryCatch({
[21:39:09.825] base::withCallingHandlers({
[21:39:09.825] ...future.value <- base::withVisible(base::local(NA))
[21:39:09.825] future::FutureResult(value = ...future.value$value,
[21:39:09.825] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:09.825] ...future.rng), globalenv = if (FALSE)
[21:39:09.825] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:09.825] ...future.globalenv.names))
[21:39:09.825] else NULL, started = ...future.startTime, version = "1.8")
[21:39:09.825] }, condition = base::local({
[21:39:09.825] c <- base::c
[21:39:09.825] inherits <- base::inherits
[21:39:09.825] invokeRestart <- base::invokeRestart
[21:39:09.825] length <- base::length
[21:39:09.825] list <- base::list
[21:39:09.825] seq.int <- base::seq.int
[21:39:09.825] signalCondition <- base::signalCondition
[21:39:09.825] sys.calls <- base::sys.calls
[21:39:09.825] `[[` <- base::`[[`
[21:39:09.825] `+` <- base::`+`
[21:39:09.825] `<<-` <- base::`<<-`
[21:39:09.825] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:09.825] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:09.825] 3L)]
[21:39:09.825] }
[21:39:09.825] function(cond) {
[21:39:09.825] is_error <- inherits(cond, "error")
[21:39:09.825] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:09.825] NULL)
[21:39:09.825] if (is_error) {
[21:39:09.825] sessionInformation <- function() {
[21:39:09.825] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:09.825] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:09.825] search = base::search(), system = base::Sys.info())
[21:39:09.825] }
[21:39:09.825] ...future.conditions[[length(...future.conditions) +
[21:39:09.825] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:09.825] cond$call), session = sessionInformation(),
[21:39:09.825] timestamp = base::Sys.time(), signaled = 0L)
[21:39:09.825] signalCondition(cond)
[21:39:09.825] }
[21:39:09.825] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:09.825] "immediateCondition"))) {
[21:39:09.825] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:09.825] ...future.conditions[[length(...future.conditions) +
[21:39:09.825] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:09.825] if (TRUE && !signal) {
[21:39:09.825] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:09.825] {
[21:39:09.825] inherits <- base::inherits
[21:39:09.825] invokeRestart <- base::invokeRestart
[21:39:09.825] is.null <- base::is.null
[21:39:09.825] muffled <- FALSE
[21:39:09.825] if (inherits(cond, "message")) {
[21:39:09.825] muffled <- grepl(pattern, "muffleMessage")
[21:39:09.825] if (muffled)
[21:39:09.825] invokeRestart("muffleMessage")
[21:39:09.825] }
[21:39:09.825] else if (inherits(cond, "warning")) {
[21:39:09.825] muffled <- grepl(pattern, "muffleWarning")
[21:39:09.825] if (muffled)
[21:39:09.825] invokeRestart("muffleWarning")
[21:39:09.825] }
[21:39:09.825] else if (inherits(cond, "condition")) {
[21:39:09.825] if (!is.null(pattern)) {
[21:39:09.825] computeRestarts <- base::computeRestarts
[21:39:09.825] grepl <- base::grepl
[21:39:09.825] restarts <- computeRestarts(cond)
[21:39:09.825] for (restart in restarts) {
[21:39:09.825] name <- restart$name
[21:39:09.825] if (is.null(name))
[21:39:09.825] next
[21:39:09.825] if (!grepl(pattern, name))
[21:39:09.825] next
[21:39:09.825] invokeRestart(restart)
[21:39:09.825] muffled <- TRUE
[21:39:09.825] break
[21:39:09.825] }
[21:39:09.825] }
[21:39:09.825] }
[21:39:09.825] invisible(muffled)
[21:39:09.825] }
[21:39:09.825] muffleCondition(cond, pattern = "^muffle")
[21:39:09.825] }
[21:39:09.825] }
[21:39:09.825] else {
[21:39:09.825] if (TRUE) {
[21:39:09.825] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:09.825] {
[21:39:09.825] inherits <- base::inherits
[21:39:09.825] invokeRestart <- base::invokeRestart
[21:39:09.825] is.null <- base::is.null
[21:39:09.825] muffled <- FALSE
[21:39:09.825] if (inherits(cond, "message")) {
[21:39:09.825] muffled <- grepl(pattern, "muffleMessage")
[21:39:09.825] if (muffled)
[21:39:09.825] invokeRestart("muffleMessage")
[21:39:09.825] }
[21:39:09.825] else if (inherits(cond, "warning")) {
[21:39:09.825] muffled <- grepl(pattern, "muffleWarning")
[21:39:09.825] if (muffled)
[21:39:09.825] invokeRestart("muffleWarning")
[21:39:09.825] }
[21:39:09.825] else if (inherits(cond, "condition")) {
[21:39:09.825] if (!is.null(pattern)) {
[21:39:09.825] computeRestarts <- base::computeRestarts
[21:39:09.825] grepl <- base::grepl
[21:39:09.825] restarts <- computeRestarts(cond)
[21:39:09.825] for (restart in restarts) {
[21:39:09.825] name <- restart$name
[21:39:09.825] if (is.null(name))
[21:39:09.825] next
[21:39:09.825] if (!grepl(pattern, name))
[21:39:09.825] next
[21:39:09.825] invokeRestart(restart)
[21:39:09.825] muffled <- TRUE
[21:39:09.825] break
[21:39:09.825] }
[21:39:09.825] }
[21:39:09.825] }
[21:39:09.825] invisible(muffled)
[21:39:09.825] }
[21:39:09.825] muffleCondition(cond, pattern = "^muffle")
[21:39:09.825] }
[21:39:09.825] }
[21:39:09.825] }
[21:39:09.825] }))
[21:39:09.825] }, error = function(ex) {
[21:39:09.825] base::structure(base::list(value = NULL, visible = NULL,
[21:39:09.825] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:09.825] ...future.rng), started = ...future.startTime,
[21:39:09.825] finished = Sys.time(), session_uuid = NA_character_,
[21:39:09.825] version = "1.8"), class = "FutureResult")
[21:39:09.825] }, finally = {
[21:39:09.825] if (!identical(...future.workdir, getwd()))
[21:39:09.825] setwd(...future.workdir)
[21:39:09.825] {
[21:39:09.825] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:09.825] ...future.oldOptions$nwarnings <- NULL
[21:39:09.825] }
[21:39:09.825] base::options(...future.oldOptions)
[21:39:09.825] if (.Platform$OS.type == "windows") {
[21:39:09.825] old_names <- names(...future.oldEnvVars)
[21:39:09.825] envs <- base::Sys.getenv()
[21:39:09.825] names <- names(envs)
[21:39:09.825] common <- intersect(names, old_names)
[21:39:09.825] added <- setdiff(names, old_names)
[21:39:09.825] removed <- setdiff(old_names, names)
[21:39:09.825] changed <- common[...future.oldEnvVars[common] !=
[21:39:09.825] envs[common]]
[21:39:09.825] NAMES <- toupper(changed)
[21:39:09.825] args <- list()
[21:39:09.825] for (kk in seq_along(NAMES)) {
[21:39:09.825] name <- changed[[kk]]
[21:39:09.825] NAME <- NAMES[[kk]]
[21:39:09.825] if (name != NAME && is.element(NAME, old_names))
[21:39:09.825] next
[21:39:09.825] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:09.825] }
[21:39:09.825] NAMES <- toupper(added)
[21:39:09.825] for (kk in seq_along(NAMES)) {
[21:39:09.825] name <- added[[kk]]
[21:39:09.825] NAME <- NAMES[[kk]]
[21:39:09.825] if (name != NAME && is.element(NAME, old_names))
[21:39:09.825] next
[21:39:09.825] args[[name]] <- ""
[21:39:09.825] }
[21:39:09.825] NAMES <- toupper(removed)
[21:39:09.825] for (kk in seq_along(NAMES)) {
[21:39:09.825] name <- removed[[kk]]
[21:39:09.825] NAME <- NAMES[[kk]]
[21:39:09.825] if (name != NAME && is.element(NAME, old_names))
[21:39:09.825] next
[21:39:09.825] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:09.825] }
[21:39:09.825] if (length(args) > 0)
[21:39:09.825] base::do.call(base::Sys.setenv, args = args)
[21:39:09.825] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:09.825] }
[21:39:09.825] else {
[21:39:09.825] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:09.825] }
[21:39:09.825] {
[21:39:09.825] if (base::length(...future.futureOptionsAdded) >
[21:39:09.825] 0L) {
[21:39:09.825] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:09.825] base::names(opts) <- ...future.futureOptionsAdded
[21:39:09.825] base::options(opts)
[21:39:09.825] }
[21:39:09.825] {
[21:39:09.825] {
[21:39:09.825] NULL
[21:39:09.825] RNGkind("Mersenne-Twister")
[21:39:09.825] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:09.825] inherits = FALSE)
[21:39:09.825] }
[21:39:09.825] options(future.plan = NULL)
[21:39:09.825] if (is.na(NA_character_))
[21:39:09.825] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:09.825] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:09.825] future::plan(list(function (..., workers = availableCores(),
[21:39:09.825] lazy = FALSE, rscript_libs = .libPaths(),
[21:39:09.825] envir = parent.frame())
[21:39:09.825] {
[21:39:09.825] if (is.function(workers))
[21:39:09.825] workers <- workers()
[21:39:09.825] workers <- structure(as.integer(workers),
[21:39:09.825] class = class(workers))
[21:39:09.825] stop_if_not(length(workers) == 1, is.finite(workers),
[21:39:09.825] workers >= 1)
[21:39:09.825] if (workers == 1L && !inherits(workers, "AsIs")) {
[21:39:09.825] return(sequential(..., lazy = TRUE, envir = envir))
[21:39:09.825] }
[21:39:09.825] future <- MultisessionFuture(..., workers = workers,
[21:39:09.825] lazy = lazy, rscript_libs = rscript_libs,
[21:39:09.825] envir = envir)
[21:39:09.825] if (!future$lazy)
[21:39:09.825] future <- run(future)
[21:39:09.825] invisible(future)
[21:39:09.825] }), .cleanup = FALSE, .init = FALSE)
[21:39:09.825] }
[21:39:09.825] }
[21:39:09.825] }
[21:39:09.825] })
[21:39:09.825] if (TRUE) {
[21:39:09.825] base::sink(type = "output", split = FALSE)
[21:39:09.825] if (TRUE) {
[21:39:09.825] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:09.825] }
[21:39:09.825] else {
[21:39:09.825] ...future.result["stdout"] <- base::list(NULL)
[21:39:09.825] }
[21:39:09.825] base::close(...future.stdout)
[21:39:09.825] ...future.stdout <- NULL
[21:39:09.825] }
[21:39:09.825] ...future.result$conditions <- ...future.conditions
[21:39:09.825] ...future.result$finished <- base::Sys.time()
[21:39:09.825] ...future.result
[21:39:09.825] }
[21:39:09.830] plan(): Setting new future strategy stack:
[21:39:09.830] List of future strategies:
[21:39:09.830] 1. sequential:
[21:39:09.830] - args: function (..., envir = parent.frame())
[21:39:09.830] - tweaked: FALSE
[21:39:09.830] - call: NULL
[21:39:09.831] plan(): nbrOfWorkers() = 1
[21:39:09.833] plan(): Setting new future strategy stack:
[21:39:09.833] List of future strategies:
[21:39:09.833] 1. multisession:
[21:39:09.833] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[21:39:09.833] - tweaked: FALSE
[21:39:09.833] - call: plan(strategy)
[21:39:09.890] plan(): nbrOfWorkers() = 1
[21:39:09.890] SequentialFuture started (and completed)
[21:39:09.891] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[21:39:09.927] plan(): nbrOfWorkers() = 1
* future_lapply(x, ..., future.stdout = FALSE) ...
[21:39:09.928] future_lapply() ...
[21:39:09.954] Number of chunks: 1
[21:39:09.954] getGlobalsAndPackagesXApply() ...
[21:39:09.955] - future.globals: TRUE
[21:39:09.955] getGlobalsAndPackages() ...
[21:39:09.955] Searching for globals...
[21:39:09.959] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[21:39:09.959] Searching for globals ... DONE
[21:39:09.959] Resolving globals: FALSE
[21:39:09.960] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[21:39:09.961] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[21:39:09.961] - globals: [1] 'FUN'
[21:39:09.962]
[21:39:09.962] getGlobalsAndPackages() ... DONE
[21:39:09.962] - globals found/used: [n=1] 'FUN'
[21:39:09.962] - needed namespaces: [n=0]
[21:39:09.962] Finding globals ... DONE
[21:39:09.963] - use_args: TRUE
[21:39:09.963] - Getting '...' globals ...
[21:39:09.964] resolve() on list ...
[21:39:09.964] recursive: 0
[21:39:09.964] length: 1
[21:39:09.964] elements: '...'
[21:39:09.984] length: 0 (resolved future 1)
[21:39:09.985] resolve() on list ... DONE
[21:39:09.985] - '...' content: [n=0]
[21:39:09.985] List of 1
[21:39:09.985] $ ...: list()
[21:39:09.985] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:09.985] - attr(*, "where")=List of 1
[21:39:09.985] ..$ ...:<environment: 0x55c1f04b1330>
[21:39:09.985] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:09.985] - attr(*, "resolved")= logi TRUE
[21:39:09.985] - attr(*, "total_size")= num NA
[21:39:09.992] - Getting '...' globals ... DONE
[21:39:09.993] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[21:39:09.993] List of 2
[21:39:09.993] $ ...future.FUN:function (x)
[21:39:09.993] $ ... : list()
[21:39:09.993] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:09.993] - attr(*, "where")=List of 2
[21:39:09.993] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:09.993] ..$ ... :<environment: 0x55c1f04b1330>
[21:39:09.993] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:09.993] - attr(*, "resolved")= logi FALSE
[21:39:09.993] - attr(*, "total_size")= num 4720
[21:39:09.999] Packages to be attached in all futures: [n=0]
[21:39:09.999] getGlobalsAndPackagesXApply() ... DONE
[21:39:10.000] Number of futures (= number of chunks): 1
[21:39:10.000] Launching 1 futures (chunks) ...
[21:39:10.000] Chunk #1 of 1 ...
[21:39:10.001] - Finding globals in 'X' for chunk #1 ...
[21:39:10.001] getGlobalsAndPackages() ...
[21:39:10.001] Searching for globals...
[21:39:10.002]
[21:39:10.002] Searching for globals ... DONE
[21:39:10.002] - globals: [0] <none>
[21:39:10.002] getGlobalsAndPackages() ... DONE
[21:39:10.003] + additional globals found: [n=0]
[21:39:10.003] + additional namespaces needed: [n=0]
[21:39:10.003] - Finding globals in 'X' for chunk #1 ... DONE
[21:39:10.004] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:10.004] - seeds: <none>
[21:39:10.004] getGlobalsAndPackages() ...
[21:39:10.004] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:10.005] Resolving globals: FALSE
[21:39:10.005] Tweak future expression to call with '...' arguments ...
[21:39:10.005] {
[21:39:10.005] do.call(function(...) {
[21:39:10.005] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:10.005] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:10.005] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:10.005] on.exit(options(oopts), add = TRUE)
[21:39:10.005] }
[21:39:10.005] {
[21:39:10.005] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:10.005] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:10.005] ...future.FUN(...future.X_jj, ...)
[21:39:10.005] })
[21:39:10.005] }
[21:39:10.005] }, args = future.call.arguments)
[21:39:10.005] }
[21:39:10.006] Tweak future expression to call with '...' arguments ... DONE
[21:39:10.026] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:10.027]
[21:39:10.027] getGlobalsAndPackages() ... DONE
[21:39:10.028] run() for 'Future' ...
[21:39:10.028] - state: 'created'
[21:39:10.028] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[21:39:10.062] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:10.062] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:10.063] - Field: 'label'
[21:39:10.063] - Field: 'local'
[21:39:10.063] - Field: 'owner'
[21:39:10.063] - Field: 'envir'
[21:39:10.064] - Field: 'packages'
[21:39:10.064] - Field: 'gc'
[21:39:10.064] - Field: 'conditions'
[21:39:10.064] - Field: 'expr'
[21:39:10.065] - Field: 'uuid'
[21:39:10.065] - Field: 'seed'
[21:39:10.065] - Field: 'version'
[21:39:10.065] - Field: 'result'
[21:39:10.066] - Field: 'asynchronous'
[21:39:10.066] - Field: 'calls'
[21:39:10.066] - Field: 'globals'
[21:39:10.066] - Field: 'stdout'
[21:39:10.067] - Field: 'earlySignal'
[21:39:10.067] - Field: 'lazy'
[21:39:10.067] - Field: 'state'
[21:39:10.067] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:10.068] - Launch lazy future ...
[21:39:10.068] Packages needed by the future expression (n = 0): <none>
[21:39:10.068] Packages needed by future strategies (n = 0): <none>
[21:39:10.069] {
[21:39:10.069] {
[21:39:10.069] {
[21:39:10.069] ...future.startTime <- base::Sys.time()
[21:39:10.069] {
[21:39:10.069] {
[21:39:10.069] {
[21:39:10.069] base::local({
[21:39:10.069] has_future <- base::requireNamespace("future",
[21:39:10.069] quietly = TRUE)
[21:39:10.069] if (has_future) {
[21:39:10.069] ns <- base::getNamespace("future")
[21:39:10.069] version <- ns[[".package"]][["version"]]
[21:39:10.069] if (is.null(version))
[21:39:10.069] version <- utils::packageVersion("future")
[21:39:10.069] }
[21:39:10.069] else {
[21:39:10.069] version <- NULL
[21:39:10.069] }
[21:39:10.069] if (!has_future || version < "1.8.0") {
[21:39:10.069] info <- base::c(r_version = base::gsub("R version ",
[21:39:10.069] "", base::R.version$version.string),
[21:39:10.069] platform = base::sprintf("%s (%s-bit)",
[21:39:10.069] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:10.069] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:10.069] "release", "version")], collapse = " "),
[21:39:10.069] hostname = base::Sys.info()[["nodename"]])
[21:39:10.069] info <- base::sprintf("%s: %s", base::names(info),
[21:39:10.069] info)
[21:39:10.069] info <- base::paste(info, collapse = "; ")
[21:39:10.069] if (!has_future) {
[21:39:10.069] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:10.069] info)
[21:39:10.069] }
[21:39:10.069] else {
[21:39:10.069] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:10.069] info, version)
[21:39:10.069] }
[21:39:10.069] base::stop(msg)
[21:39:10.069] }
[21:39:10.069] })
[21:39:10.069] }
[21:39:10.069] options(future.plan = NULL)
[21:39:10.069] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:10.069] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:10.069] }
[21:39:10.069] ...future.workdir <- getwd()
[21:39:10.069] }
[21:39:10.069] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:10.069] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:10.069] }
[21:39:10.069] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:10.069] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:10.069] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:10.069] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:10.069] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:10.069] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:10.069] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:10.069] base::names(...future.oldOptions))
[21:39:10.069] }
[21:39:10.069] if (FALSE) {
[21:39:10.069] }
[21:39:10.069] else {
[21:39:10.069] if (FALSE) {
[21:39:10.069] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:10.069] open = "w")
[21:39:10.069] }
[21:39:10.069] else {
[21:39:10.069] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:10.069] windows = "NUL", "/dev/null"), open = "w")
[21:39:10.069] }
[21:39:10.069] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:10.069] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:10.069] base::sink(type = "output", split = FALSE)
[21:39:10.069] base::close(...future.stdout)
[21:39:10.069] }, add = TRUE)
[21:39:10.069] }
[21:39:10.069] ...future.frame <- base::sys.nframe()
[21:39:10.069] ...future.conditions <- base::list()
[21:39:10.069] ...future.rng <- base::globalenv()$.Random.seed
[21:39:10.069] if (FALSE) {
[21:39:10.069] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:10.069] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:10.069] }
[21:39:10.069] ...future.result <- base::tryCatch({
[21:39:10.069] base::withCallingHandlers({
[21:39:10.069] ...future.value <- base::withVisible(base::local({
[21:39:10.069] do.call(function(...) {
[21:39:10.069] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:10.069] if (!identical(...future.globals.maxSize.org,
[21:39:10.069] ...future.globals.maxSize)) {
[21:39:10.069] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:10.069] on.exit(options(oopts), add = TRUE)
[21:39:10.069] }
[21:39:10.069] {
[21:39:10.069] lapply(seq_along(...future.elements_ii),
[21:39:10.069] FUN = function(jj) {
[21:39:10.069] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:10.069] ...future.FUN(...future.X_jj, ...)
[21:39:10.069] })
[21:39:10.069] }
[21:39:10.069] }, args = future.call.arguments)
[21:39:10.069] }))
[21:39:10.069] future::FutureResult(value = ...future.value$value,
[21:39:10.069] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:10.069] ...future.rng), globalenv = if (FALSE)
[21:39:10.069] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:10.069] ...future.globalenv.names))
[21:39:10.069] else NULL, started = ...future.startTime, version = "1.8")
[21:39:10.069] }, condition = base::local({
[21:39:10.069] c <- base::c
[21:39:10.069] inherits <- base::inherits
[21:39:10.069] invokeRestart <- base::invokeRestart
[21:39:10.069] length <- base::length
[21:39:10.069] list <- base::list
[21:39:10.069] seq.int <- base::seq.int
[21:39:10.069] signalCondition <- base::signalCondition
[21:39:10.069] sys.calls <- base::sys.calls
[21:39:10.069] `[[` <- base::`[[`
[21:39:10.069] `+` <- base::`+`
[21:39:10.069] `<<-` <- base::`<<-`
[21:39:10.069] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:10.069] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:10.069] 3L)]
[21:39:10.069] }
[21:39:10.069] function(cond) {
[21:39:10.069] is_error <- inherits(cond, "error")
[21:39:10.069] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:10.069] NULL)
[21:39:10.069] if (is_error) {
[21:39:10.069] sessionInformation <- function() {
[21:39:10.069] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:10.069] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:10.069] search = base::search(), system = base::Sys.info())
[21:39:10.069] }
[21:39:10.069] ...future.conditions[[length(...future.conditions) +
[21:39:10.069] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:10.069] cond$call), session = sessionInformation(),
[21:39:10.069] timestamp = base::Sys.time(), signaled = 0L)
[21:39:10.069] signalCondition(cond)
[21:39:10.069] }
[21:39:10.069] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:10.069] "immediateCondition"))) {
[21:39:10.069] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:10.069] ...future.conditions[[length(...future.conditions) +
[21:39:10.069] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:10.069] if (TRUE && !signal) {
[21:39:10.069] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:10.069] {
[21:39:10.069] inherits <- base::inherits
[21:39:10.069] invokeRestart <- base::invokeRestart
[21:39:10.069] is.null <- base::is.null
[21:39:10.069] muffled <- FALSE
[21:39:10.069] if (inherits(cond, "message")) {
[21:39:10.069] muffled <- grepl(pattern, "muffleMessage")
[21:39:10.069] if (muffled)
[21:39:10.069] invokeRestart("muffleMessage")
[21:39:10.069] }
[21:39:10.069] else if (inherits(cond, "warning")) {
[21:39:10.069] muffled <- grepl(pattern, "muffleWarning")
[21:39:10.069] if (muffled)
[21:39:10.069] invokeRestart("muffleWarning")
[21:39:10.069] }
[21:39:10.069] else if (inherits(cond, "condition")) {
[21:39:10.069] if (!is.null(pattern)) {
[21:39:10.069] computeRestarts <- base::computeRestarts
[21:39:10.069] grepl <- base::grepl
[21:39:10.069] restarts <- computeRestarts(cond)
[21:39:10.069] for (restart in restarts) {
[21:39:10.069] name <- restart$name
[21:39:10.069] if (is.null(name))
[21:39:10.069] next
[21:39:10.069] if (!grepl(pattern, name))
[21:39:10.069] next
[21:39:10.069] invokeRestart(restart)
[21:39:10.069] muffled <- TRUE
[21:39:10.069] break
[21:39:10.069] }
[21:39:10.069] }
[21:39:10.069] }
[21:39:10.069] invisible(muffled)
[21:39:10.069] }
[21:39:10.069] muffleCondition(cond, pattern = "^muffle")
[21:39:10.069] }
[21:39:10.069] }
[21:39:10.069] else {
[21:39:10.069] if (TRUE) {
[21:39:10.069] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:10.069] {
[21:39:10.069] inherits <- base::inherits
[21:39:10.069] invokeRestart <- base::invokeRestart
[21:39:10.069] is.null <- base::is.null
[21:39:10.069] muffled <- FALSE
[21:39:10.069] if (inherits(cond, "message")) {
[21:39:10.069] muffled <- grepl(pattern, "muffleMessage")
[21:39:10.069] if (muffled)
[21:39:10.069] invokeRestart("muffleMessage")
[21:39:10.069] }
[21:39:10.069] else if (inherits(cond, "warning")) {
[21:39:10.069] muffled <- grepl(pattern, "muffleWarning")
[21:39:10.069] if (muffled)
[21:39:10.069] invokeRestart("muffleWarning")
[21:39:10.069] }
[21:39:10.069] else if (inherits(cond, "condition")) {
[21:39:10.069] if (!is.null(pattern)) {
[21:39:10.069] computeRestarts <- base::computeRestarts
[21:39:10.069] grepl <- base::grepl
[21:39:10.069] restarts <- computeRestarts(cond)
[21:39:10.069] for (restart in restarts) {
[21:39:10.069] name <- restart$name
[21:39:10.069] if (is.null(name))
[21:39:10.069] next
[21:39:10.069] if (!grepl(pattern, name))
[21:39:10.069] next
[21:39:10.069] invokeRestart(restart)
[21:39:10.069] muffled <- TRUE
[21:39:10.069] break
[21:39:10.069] }
[21:39:10.069] }
[21:39:10.069] }
[21:39:10.069] invisible(muffled)
[21:39:10.069] }
[21:39:10.069] muffleCondition(cond, pattern = "^muffle")
[21:39:10.069] }
[21:39:10.069] }
[21:39:10.069] }
[21:39:10.069] }))
[21:39:10.069] }, error = function(ex) {
[21:39:10.069] base::structure(base::list(value = NULL, visible = NULL,
[21:39:10.069] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:10.069] ...future.rng), started = ...future.startTime,
[21:39:10.069] finished = Sys.time(), session_uuid = NA_character_,
[21:39:10.069] version = "1.8"), class = "FutureResult")
[21:39:10.069] }, finally = {
[21:39:10.069] if (!identical(...future.workdir, getwd()))
[21:39:10.069] setwd(...future.workdir)
[21:39:10.069] {
[21:39:10.069] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:10.069] ...future.oldOptions$nwarnings <- NULL
[21:39:10.069] }
[21:39:10.069] base::options(...future.oldOptions)
[21:39:10.069] if (.Platform$OS.type == "windows") {
[21:39:10.069] old_names <- names(...future.oldEnvVars)
[21:39:10.069] envs <- base::Sys.getenv()
[21:39:10.069] names <- names(envs)
[21:39:10.069] common <- intersect(names, old_names)
[21:39:10.069] added <- setdiff(names, old_names)
[21:39:10.069] removed <- setdiff(old_names, names)
[21:39:10.069] changed <- common[...future.oldEnvVars[common] !=
[21:39:10.069] envs[common]]
[21:39:10.069] NAMES <- toupper(changed)
[21:39:10.069] args <- list()
[21:39:10.069] for (kk in seq_along(NAMES)) {
[21:39:10.069] name <- changed[[kk]]
[21:39:10.069] NAME <- NAMES[[kk]]
[21:39:10.069] if (name != NAME && is.element(NAME, old_names))
[21:39:10.069] next
[21:39:10.069] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:10.069] }
[21:39:10.069] NAMES <- toupper(added)
[21:39:10.069] for (kk in seq_along(NAMES)) {
[21:39:10.069] name <- added[[kk]]
[21:39:10.069] NAME <- NAMES[[kk]]
[21:39:10.069] if (name != NAME && is.element(NAME, old_names))
[21:39:10.069] next
[21:39:10.069] args[[name]] <- ""
[21:39:10.069] }
[21:39:10.069] NAMES <- toupper(removed)
[21:39:10.069] for (kk in seq_along(NAMES)) {
[21:39:10.069] name <- removed[[kk]]
[21:39:10.069] NAME <- NAMES[[kk]]
[21:39:10.069] if (name != NAME && is.element(NAME, old_names))
[21:39:10.069] next
[21:39:10.069] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:10.069] }
[21:39:10.069] if (length(args) > 0)
[21:39:10.069] base::do.call(base::Sys.setenv, args = args)
[21:39:10.069] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:10.069] }
[21:39:10.069] else {
[21:39:10.069] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:10.069] }
[21:39:10.069] {
[21:39:10.069] if (base::length(...future.futureOptionsAdded) >
[21:39:10.069] 0L) {
[21:39:10.069] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:10.069] base::names(opts) <- ...future.futureOptionsAdded
[21:39:10.069] base::options(opts)
[21:39:10.069] }
[21:39:10.069] {
[21:39:10.069] {
[21:39:10.069] NULL
[21:39:10.069] RNGkind("Mersenne-Twister")
[21:39:10.069] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:10.069] inherits = FALSE)
[21:39:10.069] }
[21:39:10.069] options(future.plan = NULL)
[21:39:10.069] if (is.na(NA_character_))
[21:39:10.069] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:10.069] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:10.069] future::plan(list(function (..., workers = availableCores(),
[21:39:10.069] lazy = FALSE, rscript_libs = .libPaths(),
[21:39:10.069] envir = parent.frame())
[21:39:10.069] {
[21:39:10.069] if (is.function(workers))
[21:39:10.069] workers <- workers()
[21:39:10.069] workers <- structure(as.integer(workers),
[21:39:10.069] class = class(workers))
[21:39:10.069] stop_if_not(length(workers) == 1, is.finite(workers),
[21:39:10.069] workers >= 1)
[21:39:10.069] if (workers == 1L && !inherits(workers, "AsIs")) {
[21:39:10.069] return(sequential(..., lazy = TRUE, envir = envir))
[21:39:10.069] }
[21:39:10.069] future <- MultisessionFuture(..., workers = workers,
[21:39:10.069] lazy = lazy, rscript_libs = rscript_libs,
[21:39:10.069] envir = envir)
[21:39:10.069] if (!future$lazy)
[21:39:10.069] future <- run(future)
[21:39:10.069] invisible(future)
[21:39:10.069] }), .cleanup = FALSE, .init = FALSE)
[21:39:10.069] }
[21:39:10.069] }
[21:39:10.069] }
[21:39:10.069] })
[21:39:10.069] if (TRUE) {
[21:39:10.069] base::sink(type = "output", split = FALSE)
[21:39:10.069] if (FALSE) {
[21:39:10.069] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:10.069] }
[21:39:10.069] else {
[21:39:10.069] ...future.result["stdout"] <- base::list(NULL)
[21:39:10.069] }
[21:39:10.069] base::close(...future.stdout)
[21:39:10.069] ...future.stdout <- NULL
[21:39:10.069] }
[21:39:10.069] ...future.result$conditions <- ...future.conditions
[21:39:10.069] ...future.result$finished <- base::Sys.time()
[21:39:10.069] ...future.result
[21:39:10.069] }
[21:39:10.073] assign_globals() ...
[21:39:10.074] List of 5
[21:39:10.074] $ ...future.FUN :function (x)
[21:39:10.074] $ future.call.arguments : list()
[21:39:10.074] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:10.074] $ ...future.elements_ii :List of 2
[21:39:10.074] ..$ : int 1
[21:39:10.074] ..$ : int 0
[21:39:10.074] $ ...future.seeds_ii : NULL
[21:39:10.074] $ ...future.globals.maxSize: NULL
[21:39:10.074] - attr(*, "resolved")= logi FALSE
[21:39:10.074] - attr(*, "total_size")= num 4720
[21:39:10.074] - attr(*, "where")=List of 5
[21:39:10.074] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:10.074] ..$ future.call.arguments :<environment: R_EmptyEnv>
[21:39:10.074] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:10.074] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:10.074] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:10.074] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:10.074] - attr(*, "already-done")= logi TRUE
[21:39:10.102] - reassign environment for '...future.FUN'
[21:39:10.102] - copied '...future.FUN' to environment
[21:39:10.102] - copied 'future.call.arguments' to environment
[21:39:10.111] - copied '...future.elements_ii' to environment
[21:39:10.111] - copied '...future.seeds_ii' to environment
[21:39:10.112] - copied '...future.globals.maxSize' to environment
[21:39:10.112] assign_globals() ... done
[21:39:10.112] plan(): Setting new future strategy stack:
[21:39:10.113] List of future strategies:
[21:39:10.113] 1. sequential:
[21:39:10.113] - args: function (..., envir = parent.frame())
[21:39:10.113] - tweaked: FALSE
[21:39:10.113] - call: NULL
[21:39:10.113] plan(): nbrOfWorkers() = 1
[21:39:10.616] plan(): Setting new future strategy stack:
[21:39:10.616] List of future strategies:
[21:39:10.616] 1. multisession:
[21:39:10.616] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[21:39:10.616] - tweaked: FALSE
[21:39:10.616] - call: plan(strategy)
[21:39:10.652] plan(): nbrOfWorkers() = 1
[21:39:10.653] SequentialFuture started (and completed)
[21:39:10.653] - Launch lazy future ... done
[21:39:10.653] run() for 'SequentialFuture' ... done
[21:39:10.654] Created future:
[21:39:10.654] SequentialFuture:
[21:39:10.654] Label: 'future_lapply-1'
[21:39:10.654] Expression:
[21:39:10.654] {
[21:39:10.654] do.call(function(...) {
[21:39:10.654] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:10.654] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:10.654] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:10.654] on.exit(options(oopts), add = TRUE)
[21:39:10.654] }
[21:39:10.654] {
[21:39:10.654] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:10.654] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:10.654] ...future.FUN(...future.X_jj, ...)
[21:39:10.654] })
[21:39:10.654] }
[21:39:10.654] }, args = future.call.arguments)
[21:39:10.654] }
[21:39:10.654] Lazy evaluation: FALSE
[21:39:10.654] Asynchronous evaluation: FALSE
[21:39:10.654] Local evaluation: TRUE
[21:39:10.654] Environment: R_GlobalEnv
[21:39:10.654] Capture standard output: FALSE
[21:39:10.654] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:10.654] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:10.654] Packages: <none>
[21:39:10.654] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:10.654] Resolved: TRUE
[21:39:10.654] Value: 112 bytes of class 'list'
[21:39:10.654] Early signaling: FALSE
[21:39:10.654] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:10.654] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:10.656] Chunk #1 of 1 ... DONE
[21:39:10.656] Launching 1 futures (chunks) ... DONE
[21:39:10.657] Resolving 1 futures (chunks) ...
[21:39:10.657] resolve() on list ...
[21:39:10.657] recursive: 0
[21:39:10.657] length: 1
[21:39:10.658]
[21:39:10.658] resolved() for 'SequentialFuture' ...
[21:39:10.658] - state: 'finished'
[21:39:10.658] - run: TRUE
[21:39:10.658] - result: 'FutureResult'
[21:39:10.659] resolved() for 'SequentialFuture' ... done
[21:39:10.659] Future #1
[21:39:10.659] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:10.659] - nx: 1
[21:39:10.660] - relay: TRUE
[21:39:10.660] - stdout: TRUE
[21:39:10.660] - signal: TRUE
[21:39:10.660] - resignal: FALSE
[21:39:10.660] - force: TRUE
[21:39:10.661] - relayed: [n=1] FALSE
[21:39:10.661] - queued futures: [n=1] FALSE
[21:39:10.661] - until=1
[21:39:10.661] - relaying element #1
[21:39:10.662] - relayed: [n=1] TRUE
[21:39:10.662] - queued futures: [n=1] TRUE
[21:39:10.662] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:10.662] length: 0 (resolved future 1)
[21:39:10.679] Relaying remaining futures
[21:39:10.679] signalConditionsASAP(NULL, pos=0) ...
[21:39:10.679] - nx: 1
[21:39:10.679] - relay: TRUE
[21:39:10.680] - stdout: TRUE
[21:39:10.680] - signal: TRUE
[21:39:10.680] - resignal: FALSE
[21:39:10.680] - force: TRUE
[21:39:10.680] - relayed: [n=1] TRUE
[21:39:10.680] - queued futures: [n=1] TRUE
- flush all
[21:39:10.681] - relayed: [n=1] TRUE
[21:39:10.681] - queued futures: [n=1] TRUE
[21:39:10.681] signalConditionsASAP(NULL, pos=0) ... done
[21:39:10.681] resolve() on list ... DONE
[21:39:10.682] - Number of value chunks collected: 1
[21:39:10.682] Resolving 1 futures (chunks) ... DONE
[21:39:10.682] Reducing values from 1 chunks ...
[21:39:10.682] - Number of values collected after concatenation: 2
[21:39:10.683] - Number of values expected: 2
[21:39:10.683] Reducing values from 1 chunks ... DONE
[21:39:10.683] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = FALSE) ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ...
[21:39:10.684] future_lapply() ...
[21:39:10.705] Number of chunks: 1
[21:39:10.705] getGlobalsAndPackagesXApply() ...
[21:39:10.706] - future.globals: TRUE
[21:39:10.706] getGlobalsAndPackages() ...
[21:39:10.706] Searching for globals...
[21:39:10.709] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[21:39:10.710] Searching for globals ... DONE
[21:39:10.710] Resolving globals: FALSE
[21:39:10.711] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[21:39:10.712] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[21:39:10.712] - globals: [1] 'FUN'
[21:39:10.712]
[21:39:10.712] getGlobalsAndPackages() ... DONE
[21:39:10.713] - globals found/used: [n=1] 'FUN'
[21:39:10.713] - needed namespaces: [n=0]
[21:39:10.713] Finding globals ... DONE
[21:39:10.713] - use_args: TRUE
[21:39:10.714] - Getting '...' globals ...
[21:39:10.714] resolve() on list ...
[21:39:10.715] recursive: 0
[21:39:10.715] length: 1
[21:39:10.715] elements: '...'
[21:39:10.715] length: 0 (resolved future 1)
[21:39:10.715] resolve() on list ... DONE
[21:39:10.716] - '...' content: [n=0]
[21:39:10.716] List of 1
[21:39:10.716] $ ...: list()
[21:39:10.716] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:10.716] - attr(*, "where")=List of 1
[21:39:10.716] ..$ ...:<environment: 0x55c1ef1d3c78>
[21:39:10.716] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:10.716] - attr(*, "resolved")= logi TRUE
[21:39:10.716] - attr(*, "total_size")= num NA
[21:39:10.722] - Getting '...' globals ... DONE
[21:39:10.722] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[21:39:10.722] List of 2
[21:39:10.722] $ ...future.FUN:function (x)
[21:39:10.722] $ ... : list()
[21:39:10.722] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:10.722] - attr(*, "where")=List of 2
[21:39:10.722] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:10.722] ..$ ... :<environment: 0x55c1ef1d3c78>
[21:39:10.722] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:10.722] - attr(*, "resolved")= logi FALSE
[21:39:10.722] - attr(*, "total_size")= num 4720
[21:39:10.729] Packages to be attached in all futures: [n=0]
[21:39:10.729] getGlobalsAndPackagesXApply() ... DONE
[21:39:10.730] Number of futures (= number of chunks): 1
[21:39:10.730] Launching 1 futures (chunks) ...
[21:39:10.730] Chunk #1 of 1 ...
[21:39:10.730] - Finding globals in 'X' for chunk #1 ...
[21:39:10.731] getGlobalsAndPackages() ...
[21:39:10.731] Searching for globals...
[21:39:10.732]
[21:39:10.732] Searching for globals ... DONE
[21:39:10.732] - globals: [0] <none>
[21:39:10.732] getGlobalsAndPackages() ... DONE
[21:39:10.732] + additional globals found: [n=0]
[21:39:10.733] + additional namespaces needed: [n=0]
[21:39:10.733] - Finding globals in 'X' for chunk #1 ... DONE
[21:39:10.733] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:10.734] - seeds: <none>
[21:39:10.734] getGlobalsAndPackages() ...
[21:39:10.734] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:10.734] Resolving globals: FALSE
[21:39:10.735] Tweak future expression to call with '...' arguments ...
[21:39:10.735] {
[21:39:10.735] do.call(function(...) {
[21:39:10.735] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:10.735] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:10.735] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:10.735] on.exit(options(oopts), add = TRUE)
[21:39:10.735] }
[21:39:10.735] {
[21:39:10.735] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:10.735] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:10.735] ...future.FUN(...future.X_jj, ...)
[21:39:10.735] })
[21:39:10.735] }
[21:39:10.735] }, args = future.call.arguments)
[21:39:10.735] }
[21:39:10.735] Tweak future expression to call with '...' arguments ... DONE
[21:39:10.737] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:10.737]
[21:39:10.738] getGlobalsAndPackages() ... DONE
[21:39:10.741] run() for 'Future' ...
[21:39:10.741] - state: 'created'
[21:39:10.742] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[21:39:10.777] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:10.777] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:10.778] - Field: 'label'
[21:39:10.778] - Field: 'local'
[21:39:10.778] - Field: 'owner'
[21:39:10.779] - Field: 'envir'
[21:39:10.779] - Field: 'packages'
[21:39:10.779] - Field: 'gc'
[21:39:10.779] - Field: 'conditions'
[21:39:10.779] - Field: 'expr'
[21:39:10.780] - Field: 'uuid'
[21:39:10.780] - Field: 'seed'
[21:39:10.780] - Field: 'version'
[21:39:10.780] - Field: 'result'
[21:39:10.781] - Field: 'asynchronous'
[21:39:10.781] - Field: 'calls'
[21:39:10.781] - Field: 'globals'
[21:39:10.781] - Field: 'stdout'
[21:39:10.781] - Field: 'earlySignal'
[21:39:10.782] - Field: 'lazy'
[21:39:10.782] - Field: 'state'
[21:39:10.782] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:10.782] - Launch lazy future ...
[21:39:10.783] Packages needed by the future expression (n = 0): <none>
[21:39:10.783] Packages needed by future strategies (n = 0): <none>
[21:39:10.784] {
[21:39:10.784] {
[21:39:10.784] {
[21:39:10.784] ...future.startTime <- base::Sys.time()
[21:39:10.784] {
[21:39:10.784] {
[21:39:10.784] {
[21:39:10.784] base::local({
[21:39:10.784] has_future <- base::requireNamespace("future",
[21:39:10.784] quietly = TRUE)
[21:39:10.784] if (has_future) {
[21:39:10.784] ns <- base::getNamespace("future")
[21:39:10.784] version <- ns[[".package"]][["version"]]
[21:39:10.784] if (is.null(version))
[21:39:10.784] version <- utils::packageVersion("future")
[21:39:10.784] }
[21:39:10.784] else {
[21:39:10.784] version <- NULL
[21:39:10.784] }
[21:39:10.784] if (!has_future || version < "1.8.0") {
[21:39:10.784] info <- base::c(r_version = base::gsub("R version ",
[21:39:10.784] "", base::R.version$version.string),
[21:39:10.784] platform = base::sprintf("%s (%s-bit)",
[21:39:10.784] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:10.784] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:10.784] "release", "version")], collapse = " "),
[21:39:10.784] hostname = base::Sys.info()[["nodename"]])
[21:39:10.784] info <- base::sprintf("%s: %s", base::names(info),
[21:39:10.784] info)
[21:39:10.784] info <- base::paste(info, collapse = "; ")
[21:39:10.784] if (!has_future) {
[21:39:10.784] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:10.784] info)
[21:39:10.784] }
[21:39:10.784] else {
[21:39:10.784] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:10.784] info, version)
[21:39:10.784] }
[21:39:10.784] base::stop(msg)
[21:39:10.784] }
[21:39:10.784] })
[21:39:10.784] }
[21:39:10.784] options(future.plan = NULL)
[21:39:10.784] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:10.784] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:10.784] }
[21:39:10.784] ...future.workdir <- getwd()
[21:39:10.784] }
[21:39:10.784] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:10.784] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:10.784] }
[21:39:10.784] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:10.784] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:10.784] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:10.784] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:10.784] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:10.784] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:10.784] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:10.784] base::names(...future.oldOptions))
[21:39:10.784] }
[21:39:10.784] if (FALSE) {
[21:39:10.784] }
[21:39:10.784] else {
[21:39:10.784] if (TRUE) {
[21:39:10.784] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:10.784] open = "w")
[21:39:10.784] }
[21:39:10.784] else {
[21:39:10.784] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:10.784] windows = "NUL", "/dev/null"), open = "w")
[21:39:10.784] }
[21:39:10.784] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:10.784] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:10.784] base::sink(type = "output", split = FALSE)
[21:39:10.784] base::close(...future.stdout)
[21:39:10.784] }, add = TRUE)
[21:39:10.784] }
[21:39:10.784] ...future.frame <- base::sys.nframe()
[21:39:10.784] ...future.conditions <- base::list()
[21:39:10.784] ...future.rng <- base::globalenv()$.Random.seed
[21:39:10.784] if (FALSE) {
[21:39:10.784] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:10.784] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:10.784] }
[21:39:10.784] ...future.result <- base::tryCatch({
[21:39:10.784] base::withCallingHandlers({
[21:39:10.784] ...future.value <- base::withVisible(base::local({
[21:39:10.784] do.call(function(...) {
[21:39:10.784] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:10.784] if (!identical(...future.globals.maxSize.org,
[21:39:10.784] ...future.globals.maxSize)) {
[21:39:10.784] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:10.784] on.exit(options(oopts), add = TRUE)
[21:39:10.784] }
[21:39:10.784] {
[21:39:10.784] lapply(seq_along(...future.elements_ii),
[21:39:10.784] FUN = function(jj) {
[21:39:10.784] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:10.784] ...future.FUN(...future.X_jj, ...)
[21:39:10.784] })
[21:39:10.784] }
[21:39:10.784] }, args = future.call.arguments)
[21:39:10.784] }))
[21:39:10.784] future::FutureResult(value = ...future.value$value,
[21:39:10.784] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:10.784] ...future.rng), globalenv = if (FALSE)
[21:39:10.784] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:10.784] ...future.globalenv.names))
[21:39:10.784] else NULL, started = ...future.startTime, version = "1.8")
[21:39:10.784] }, condition = base::local({
[21:39:10.784] c <- base::c
[21:39:10.784] inherits <- base::inherits
[21:39:10.784] invokeRestart <- base::invokeRestart
[21:39:10.784] length <- base::length
[21:39:10.784] list <- base::list
[21:39:10.784] seq.int <- base::seq.int
[21:39:10.784] signalCondition <- base::signalCondition
[21:39:10.784] sys.calls <- base::sys.calls
[21:39:10.784] `[[` <- base::`[[`
[21:39:10.784] `+` <- base::`+`
[21:39:10.784] `<<-` <- base::`<<-`
[21:39:10.784] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:10.784] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:10.784] 3L)]
[21:39:10.784] }
[21:39:10.784] function(cond) {
[21:39:10.784] is_error <- inherits(cond, "error")
[21:39:10.784] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:10.784] NULL)
[21:39:10.784] if (is_error) {
[21:39:10.784] sessionInformation <- function() {
[21:39:10.784] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:10.784] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:10.784] search = base::search(), system = base::Sys.info())
[21:39:10.784] }
[21:39:10.784] ...future.conditions[[length(...future.conditions) +
[21:39:10.784] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:10.784] cond$call), session = sessionInformation(),
[21:39:10.784] timestamp = base::Sys.time(), signaled = 0L)
[21:39:10.784] signalCondition(cond)
[21:39:10.784] }
[21:39:10.784] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:10.784] "immediateCondition"))) {
[21:39:10.784] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:10.784] ...future.conditions[[length(...future.conditions) +
[21:39:10.784] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:10.784] if (TRUE && !signal) {
[21:39:10.784] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:10.784] {
[21:39:10.784] inherits <- base::inherits
[21:39:10.784] invokeRestart <- base::invokeRestart
[21:39:10.784] is.null <- base::is.null
[21:39:10.784] muffled <- FALSE
[21:39:10.784] if (inherits(cond, "message")) {
[21:39:10.784] muffled <- grepl(pattern, "muffleMessage")
[21:39:10.784] if (muffled)
[21:39:10.784] invokeRestart("muffleMessage")
[21:39:10.784] }
[21:39:10.784] else if (inherits(cond, "warning")) {
[21:39:10.784] muffled <- grepl(pattern, "muffleWarning")
[21:39:10.784] if (muffled)
[21:39:10.784] invokeRestart("muffleWarning")
[21:39:10.784] }
[21:39:10.784] else if (inherits(cond, "condition")) {
[21:39:10.784] if (!is.null(pattern)) {
[21:39:10.784] computeRestarts <- base::computeRestarts
[21:39:10.784] grepl <- base::grepl
[21:39:10.784] restarts <- computeRestarts(cond)
[21:39:10.784] for (restart in restarts) {
[21:39:10.784] name <- restart$name
[21:39:10.784] if (is.null(name))
[21:39:10.784] next
[21:39:10.784] if (!grepl(pattern, name))
[21:39:10.784] next
[21:39:10.784] invokeRestart(restart)
[21:39:10.784] muffled <- TRUE
[21:39:10.784] break
[21:39:10.784] }
[21:39:10.784] }
[21:39:10.784] }
[21:39:10.784] invisible(muffled)
[21:39:10.784] }
[21:39:10.784] muffleCondition(cond, pattern = "^muffle")
[21:39:10.784] }
[21:39:10.784] }
[21:39:10.784] else {
[21:39:10.784] if (TRUE) {
[21:39:10.784] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:10.784] {
[21:39:10.784] inherits <- base::inherits
[21:39:10.784] invokeRestart <- base::invokeRestart
[21:39:10.784] is.null <- base::is.null
[21:39:10.784] muffled <- FALSE
[21:39:10.784] if (inherits(cond, "message")) {
[21:39:10.784] muffled <- grepl(pattern, "muffleMessage")
[21:39:10.784] if (muffled)
[21:39:10.784] invokeRestart("muffleMessage")
[21:39:10.784] }
[21:39:10.784] else if (inherits(cond, "warning")) {
[21:39:10.784] muffled <- grepl(pattern, "muffleWarning")
[21:39:10.784] if (muffled)
[21:39:10.784] invokeRestart("muffleWarning")
[21:39:10.784] }
[21:39:10.784] else if (inherits(cond, "condition")) {
[21:39:10.784] if (!is.null(pattern)) {
[21:39:10.784] computeRestarts <- base::computeRestarts
[21:39:10.784] grepl <- base::grepl
[21:39:10.784] restarts <- computeRestarts(cond)
[21:39:10.784] for (restart in restarts) {
[21:39:10.784] name <- restart$name
[21:39:10.784] if (is.null(name))
[21:39:10.784] next
[21:39:10.784] if (!grepl(pattern, name))
[21:39:10.784] next
[21:39:10.784] invokeRestart(restart)
[21:39:10.784] muffled <- TRUE
[21:39:10.784] break
[21:39:10.784] }
[21:39:10.784] }
[21:39:10.784] }
[21:39:10.784] invisible(muffled)
[21:39:10.784] }
[21:39:10.784] muffleCondition(cond, pattern = "^muffle")
[21:39:10.784] }
[21:39:10.784] }
[21:39:10.784] }
[21:39:10.784] }))
[21:39:10.784] }, error = function(ex) {
[21:39:10.784] base::structure(base::list(value = NULL, visible = NULL,
[21:39:10.784] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:10.784] ...future.rng), started = ...future.startTime,
[21:39:10.784] finished = Sys.time(), session_uuid = NA_character_,
[21:39:10.784] version = "1.8"), class = "FutureResult")
[21:39:10.784] }, finally = {
[21:39:10.784] if (!identical(...future.workdir, getwd()))
[21:39:10.784] setwd(...future.workdir)
[21:39:10.784] {
[21:39:10.784] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:10.784] ...future.oldOptions$nwarnings <- NULL
[21:39:10.784] }
[21:39:10.784] base::options(...future.oldOptions)
[21:39:10.784] if (.Platform$OS.type == "windows") {
[21:39:10.784] old_names <- names(...future.oldEnvVars)
[21:39:10.784] envs <- base::Sys.getenv()
[21:39:10.784] names <- names(envs)
[21:39:10.784] common <- intersect(names, old_names)
[21:39:10.784] added <- setdiff(names, old_names)
[21:39:10.784] removed <- setdiff(old_names, names)
[21:39:10.784] changed <- common[...future.oldEnvVars[common] !=
[21:39:10.784] envs[common]]
[21:39:10.784] NAMES <- toupper(changed)
[21:39:10.784] args <- list()
[21:39:10.784] for (kk in seq_along(NAMES)) {
[21:39:10.784] name <- changed[[kk]]
[21:39:10.784] NAME <- NAMES[[kk]]
[21:39:10.784] if (name != NAME && is.element(NAME, old_names))
[21:39:10.784] next
[21:39:10.784] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:10.784] }
[21:39:10.784] NAMES <- toupper(added)
[21:39:10.784] for (kk in seq_along(NAMES)) {
[21:39:10.784] name <- added[[kk]]
[21:39:10.784] NAME <- NAMES[[kk]]
[21:39:10.784] if (name != NAME && is.element(NAME, old_names))
[21:39:10.784] next
[21:39:10.784] args[[name]] <- ""
[21:39:10.784] }
[21:39:10.784] NAMES <- toupper(removed)
[21:39:10.784] for (kk in seq_along(NAMES)) {
[21:39:10.784] name <- removed[[kk]]
[21:39:10.784] NAME <- NAMES[[kk]]
[21:39:10.784] if (name != NAME && is.element(NAME, old_names))
[21:39:10.784] next
[21:39:10.784] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:10.784] }
[21:39:10.784] if (length(args) > 0)
[21:39:10.784] base::do.call(base::Sys.setenv, args = args)
[21:39:10.784] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:10.784] }
[21:39:10.784] else {
[21:39:10.784] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:10.784] }
[21:39:10.784] {
[21:39:10.784] if (base::length(...future.futureOptionsAdded) >
[21:39:10.784] 0L) {
[21:39:10.784] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:10.784] base::names(opts) <- ...future.futureOptionsAdded
[21:39:10.784] base::options(opts)
[21:39:10.784] }
[21:39:10.784] {
[21:39:10.784] {
[21:39:10.784] NULL
[21:39:10.784] RNGkind("Mersenne-Twister")
[21:39:10.784] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:10.784] inherits = FALSE)
[21:39:10.784] }
[21:39:10.784] options(future.plan = NULL)
[21:39:10.784] if (is.na(NA_character_))
[21:39:10.784] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:10.784] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:10.784] future::plan(list(function (..., workers = availableCores(),
[21:39:10.784] lazy = FALSE, rscript_libs = .libPaths(),
[21:39:10.784] envir = parent.frame())
[21:39:10.784] {
[21:39:10.784] if (is.function(workers))
[21:39:10.784] workers <- workers()
[21:39:10.784] workers <- structure(as.integer(workers),
[21:39:10.784] class = class(workers))
[21:39:10.784] stop_if_not(length(workers) == 1, is.finite(workers),
[21:39:10.784] workers >= 1)
[21:39:10.784] if (workers == 1L && !inherits(workers, "AsIs")) {
[21:39:10.784] return(sequential(..., lazy = TRUE, envir = envir))
[21:39:10.784] }
[21:39:10.784] future <- MultisessionFuture(..., workers = workers,
[21:39:10.784] lazy = lazy, rscript_libs = rscript_libs,
[21:39:10.784] envir = envir)
[21:39:10.784] if (!future$lazy)
[21:39:10.784] future <- run(future)
[21:39:10.784] invisible(future)
[21:39:10.784] }), .cleanup = FALSE, .init = FALSE)
[21:39:10.784] }
[21:39:10.784] }
[21:39:10.784] }
[21:39:10.784] })
[21:39:10.784] if (TRUE) {
[21:39:10.784] base::sink(type = "output", split = FALSE)
[21:39:10.784] if (TRUE) {
[21:39:10.784] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:10.784] }
[21:39:10.784] else {
[21:39:10.784] ...future.result["stdout"] <- base::list(NULL)
[21:39:10.784] }
[21:39:10.784] base::close(...future.stdout)
[21:39:10.784] ...future.stdout <- NULL
[21:39:10.784] }
[21:39:10.784] ...future.result$conditions <- ...future.conditions
[21:39:10.784] ...future.result$finished <- base::Sys.time()
[21:39:10.784] ...future.result
[21:39:10.784] }
[21:39:10.788] assign_globals() ...
[21:39:10.788] List of 5
[21:39:10.788] $ ...future.FUN :function (x)
[21:39:10.788] $ future.call.arguments : list()
[21:39:10.788] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:10.788] $ ...future.elements_ii :List of 2
[21:39:10.788] ..$ : int 1
[21:39:10.788] ..$ : int 0
[21:39:10.788] $ ...future.seeds_ii : NULL
[21:39:10.788] $ ...future.globals.maxSize: NULL
[21:39:10.788] - attr(*, "resolved")= logi FALSE
[21:39:10.788] - attr(*, "total_size")= num 4720
[21:39:10.788] - attr(*, "where")=List of 5
[21:39:10.788] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:10.788] ..$ future.call.arguments :<environment: R_EmptyEnv>
[21:39:10.788] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:10.788] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:10.788] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:10.788] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:10.788] - attr(*, "already-done")= logi TRUE
[21:39:10.800] - reassign environment for '...future.FUN'
[21:39:10.800] - copied '...future.FUN' to environment
[21:39:10.800] - copied 'future.call.arguments' to environment
[21:39:10.800] - copied '...future.elements_ii' to environment
[21:39:10.801] - copied '...future.seeds_ii' to environment
[21:39:10.801] - copied '...future.globals.maxSize' to environment
[21:39:10.801] assign_globals() ... done
[21:39:10.802] plan(): Setting new future strategy stack:
[21:39:10.802] List of future strategies:
[21:39:10.802] 1. sequential:
[21:39:10.802] - args: function (..., envir = parent.frame())
[21:39:10.802] - tweaked: FALSE
[21:39:10.802] - call: NULL
[21:39:10.803] plan(): nbrOfWorkers() = 1
[21:39:11.305] plan(): Setting new future strategy stack:
[21:39:11.305] List of future strategies:
[21:39:11.305] 1. multisession:
[21:39:11.305] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[21:39:11.305] - tweaked: FALSE
[21:39:11.305] - call: plan(strategy)
[21:39:11.329] plan(): nbrOfWorkers() = 1
[21:39:11.330] SequentialFuture started (and completed)
[21:39:11.330] - Launch lazy future ... done
[21:39:11.330] run() for 'SequentialFuture' ... done
[21:39:11.331] Created future:
[21:39:11.331] SequentialFuture:
[21:39:11.331] Label: 'future_lapply-1'
[21:39:11.331] Expression:
[21:39:11.331] {
[21:39:11.331] do.call(function(...) {
[21:39:11.331] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:11.331] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:11.331] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:11.331] on.exit(options(oopts), add = TRUE)
[21:39:11.331] }
[21:39:11.331] {
[21:39:11.331] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:11.331] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:11.331] ...future.FUN(...future.X_jj, ...)
[21:39:11.331] })
[21:39:11.331] }
[21:39:11.331] }, args = future.call.arguments)
[21:39:11.331] }
[21:39:11.331] Lazy evaluation: FALSE
[21:39:11.331] Asynchronous evaluation: FALSE
[21:39:11.331] Local evaluation: TRUE
[21:39:11.331] Environment: R_GlobalEnv
[21:39:11.331] Capture standard output: TRUE
[21:39:11.331] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:11.331] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:11.331] Packages: <none>
[21:39:11.331] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:11.331] Resolved: TRUE
[21:39:11.331] Value: 112 bytes of class 'list'
[21:39:11.331] Early signaling: FALSE
[21:39:11.331] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:11.331] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:11.333] Chunk #1 of 1 ... DONE
[21:39:11.333] Launching 1 futures (chunks) ... DONE
[21:39:11.333] Resolving 1 futures (chunks) ...
[21:39:11.333] resolve() on list ...
[21:39:11.334] recursive: 0
[21:39:11.334] length: 1
[21:39:11.334]
[21:39:11.334] resolved() for 'SequentialFuture' ...
[21:39:11.334] - state: 'finished'
[21:39:11.335] - run: TRUE
[21:39:11.335] - result: 'FutureResult'
[21:39:11.335] resolved() for 'SequentialFuture' ... done
[21:39:11.335] Future #1
[21:39:11.336] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:11.336] - nx: 1
[21:39:11.336] - relay: TRUE
[21:39:11.336] - stdout: TRUE
[21:39:11.336] - signal: TRUE
[21:39:11.337] - resignal: FALSE
[21:39:11.337] - force: TRUE
[21:39:11.337] - relayed: [n=1] FALSE
[21:39:11.337] - queued futures: [n=1] FALSE
[21:39:11.337] - until=1
[21:39:11.337] - relaying element #1
[21:39:11.338] - relayed: [n=1] TRUE
[21:39:11.338] - queued futures: [n=1] TRUE
[21:39:11.338] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:11.339] length: 0 (resolved future 1)
[21:39:11.339] Relaying remaining futures
[21:39:11.339] signalConditionsASAP(NULL, pos=0) ...
[21:39:11.339] - nx: 1
[21:39:11.339] - relay: TRUE
[21:39:11.339] - stdout: TRUE
[21:39:11.340] - signal: TRUE
[21:39:11.340] - resignal: FALSE
[21:39:11.340] - force: TRUE
[21:39:11.340] - relayed: [n=1] TRUE
[21:39:11.340] - queued futures: [n=1] TRUE
- flush all
[21:39:11.341] - relayed: [n=1] TRUE
[21:39:11.341] - queued futures: [n=1] TRUE
[21:39:11.341] signalConditionsASAP(NULL, pos=0) ... done
[21:39:11.341] resolve() on list ... DONE
[21:39:11.342] - Number of value chunks collected: 1
[21:39:11.342] Resolving 1 futures (chunks) ... DONE
[21:39:11.342] Reducing values from 1 chunks ...
[21:39:11.342] - Number of values collected after concatenation: 2
[21:39:11.342] - Number of values expected: 2
[21:39:11.343] Reducing values from 1 chunks ... DONE
[21:39:11.343] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = TRUE) ... DONE
* future_lapply(x, ..., future.stdout = NA) ...
[21:39:11.344] future_lapply() ...
[21:39:11.394] Number of chunks: 1
[21:39:11.394] getGlobalsAndPackagesXApply() ...
[21:39:11.394] - future.globals: TRUE
[21:39:11.394] getGlobalsAndPackages() ...
[21:39:11.395] Searching for globals...
[21:39:11.402] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[21:39:11.402] Searching for globals ... DONE
[21:39:11.402] Resolving globals: FALSE
[21:39:11.403] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[21:39:11.404] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[21:39:11.404] - globals: [1] 'FUN'
[21:39:11.405]
[21:39:11.405] getGlobalsAndPackages() ... DONE
[21:39:11.405] - globals found/used: [n=1] 'FUN'
[21:39:11.405] - needed namespaces: [n=0]
[21:39:11.406] Finding globals ... DONE
[21:39:11.406] - use_args: TRUE
[21:39:11.406] - Getting '...' globals ...
[21:39:11.419] resolve() on list ...
[21:39:11.419] recursive: 0
[21:39:11.420] length: 1
[21:39:11.420] elements: '...'
[21:39:11.420] length: 0 (resolved future 1)
[21:39:11.420] resolve() on list ... DONE
[21:39:11.420] - '...' content: [n=0]
[21:39:11.421] List of 1
[21:39:11.421] $ ...: list()
[21:39:11.421] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:11.421] - attr(*, "where")=List of 1
[21:39:11.421] ..$ ...:<environment: 0x55c1f07f3250>
[21:39:11.421] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:11.421] - attr(*, "resolved")= logi TRUE
[21:39:11.421] - attr(*, "total_size")= num NA
[21:39:11.427] - Getting '...' globals ... DONE
[21:39:11.427] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[21:39:11.428] List of 2
[21:39:11.428] $ ...future.FUN:function (x)
[21:39:11.428] $ ... : list()
[21:39:11.428] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:11.428] - attr(*, "where")=List of 2
[21:39:11.428] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:11.428] ..$ ... :<environment: 0x55c1f07f3250>
[21:39:11.428] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:11.428] - attr(*, "resolved")= logi FALSE
[21:39:11.428] - attr(*, "total_size")= num 4720
[21:39:11.450] Packages to be attached in all futures: [n=0]
[21:39:11.451] getGlobalsAndPackagesXApply() ... DONE
[21:39:11.451] Number of futures (= number of chunks): 1
[21:39:11.451] Launching 1 futures (chunks) ...
[21:39:11.452] Chunk #1 of 1 ...
[21:39:11.452] - Finding globals in 'X' for chunk #1 ...
[21:39:11.452] getGlobalsAndPackages() ...
[21:39:11.452] Searching for globals...
[21:39:11.453]
[21:39:11.453] Searching for globals ... DONE
[21:39:11.454] - globals: [0] <none>
[21:39:11.454] getGlobalsAndPackages() ... DONE
[21:39:11.454] + additional globals found: [n=0]
[21:39:11.454] + additional namespaces needed: [n=0]
[21:39:11.454] - Finding globals in 'X' for chunk #1 ... DONE
[21:39:11.455] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:11.455] - seeds: <none>
[21:39:11.455] getGlobalsAndPackages() ...
[21:39:11.455] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:11.456] Resolving globals: FALSE
[21:39:11.456] Tweak future expression to call with '...' arguments ...
[21:39:11.456] {
[21:39:11.456] do.call(function(...) {
[21:39:11.456] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:11.456] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:11.456] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:11.456] on.exit(options(oopts), add = TRUE)
[21:39:11.456] }
[21:39:11.456] {
[21:39:11.456] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:11.456] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:11.456] ...future.FUN(...future.X_jj, ...)
[21:39:11.456] })
[21:39:11.456] }
[21:39:11.456] }, args = future.call.arguments)
[21:39:11.456] }
[21:39:11.457] Tweak future expression to call with '...' arguments ... DONE
[21:39:11.458] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:11.458]
[21:39:11.458] getGlobalsAndPackages() ... DONE
[21:39:11.459] run() for 'Future' ...
[21:39:11.459] - state: 'created'
[21:39:11.459] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[21:39:11.491] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:11.491] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:11.491] - Field: 'label'
[21:39:11.492] - Field: 'local'
[21:39:11.492] - Field: 'owner'
[21:39:11.492] - Field: 'envir'
[21:39:11.492] - Field: 'packages'
[21:39:11.493] - Field: 'gc'
[21:39:11.493] - Field: 'conditions'
[21:39:11.493] - Field: 'expr'
[21:39:11.493] - Field: 'uuid'
[21:39:11.494] - Field: 'seed'
[21:39:11.494] - Field: 'version'
[21:39:11.494] - Field: 'result'
[21:39:11.494] - Field: 'asynchronous'
[21:39:11.495] - Field: 'calls'
[21:39:11.495] - Field: 'globals'
[21:39:11.495] - Field: 'stdout'
[21:39:11.495] - Field: 'earlySignal'
[21:39:11.496] - Field: 'lazy'
[21:39:11.496] - Field: 'state'
[21:39:11.496] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:11.496] - Launch lazy future ...
[21:39:11.497] Packages needed by the future expression (n = 0): <none>
[21:39:11.497] Packages needed by future strategies (n = 0): <none>
[21:39:11.498] {
[21:39:11.498] {
[21:39:11.498] {
[21:39:11.498] ...future.startTime <- base::Sys.time()
[21:39:11.498] {
[21:39:11.498] {
[21:39:11.498] {
[21:39:11.498] base::local({
[21:39:11.498] has_future <- base::requireNamespace("future",
[21:39:11.498] quietly = TRUE)
[21:39:11.498] if (has_future) {
[21:39:11.498] ns <- base::getNamespace("future")
[21:39:11.498] version <- ns[[".package"]][["version"]]
[21:39:11.498] if (is.null(version))
[21:39:11.498] version <- utils::packageVersion("future")
[21:39:11.498] }
[21:39:11.498] else {
[21:39:11.498] version <- NULL
[21:39:11.498] }
[21:39:11.498] if (!has_future || version < "1.8.0") {
[21:39:11.498] info <- base::c(r_version = base::gsub("R version ",
[21:39:11.498] "", base::R.version$version.string),
[21:39:11.498] platform = base::sprintf("%s (%s-bit)",
[21:39:11.498] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:11.498] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:11.498] "release", "version")], collapse = " "),
[21:39:11.498] hostname = base::Sys.info()[["nodename"]])
[21:39:11.498] info <- base::sprintf("%s: %s", base::names(info),
[21:39:11.498] info)
[21:39:11.498] info <- base::paste(info, collapse = "; ")
[21:39:11.498] if (!has_future) {
[21:39:11.498] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:11.498] info)
[21:39:11.498] }
[21:39:11.498] else {
[21:39:11.498] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:11.498] info, version)
[21:39:11.498] }
[21:39:11.498] base::stop(msg)
[21:39:11.498] }
[21:39:11.498] })
[21:39:11.498] }
[21:39:11.498] options(future.plan = NULL)
[21:39:11.498] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:11.498] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:11.498] }
[21:39:11.498] ...future.workdir <- getwd()
[21:39:11.498] }
[21:39:11.498] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:11.498] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:11.498] }
[21:39:11.498] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:11.498] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:11.498] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:11.498] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:11.498] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:11.498] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:11.498] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:11.498] base::names(...future.oldOptions))
[21:39:11.498] }
[21:39:11.498] if (TRUE) {
[21:39:11.498] }
[21:39:11.498] else {
[21:39:11.498] if (NA) {
[21:39:11.498] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:11.498] open = "w")
[21:39:11.498] }
[21:39:11.498] else {
[21:39:11.498] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:11.498] windows = "NUL", "/dev/null"), open = "w")
[21:39:11.498] }
[21:39:11.498] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:11.498] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:11.498] base::sink(type = "output", split = FALSE)
[21:39:11.498] base::close(...future.stdout)
[21:39:11.498] }, add = TRUE)
[21:39:11.498] }
[21:39:11.498] ...future.frame <- base::sys.nframe()
[21:39:11.498] ...future.conditions <- base::list()
[21:39:11.498] ...future.rng <- base::globalenv()$.Random.seed
[21:39:11.498] if (FALSE) {
[21:39:11.498] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:11.498] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:11.498] }
[21:39:11.498] ...future.result <- base::tryCatch({
[21:39:11.498] base::withCallingHandlers({
[21:39:11.498] ...future.value <- base::withVisible(base::local({
[21:39:11.498] do.call(function(...) {
[21:39:11.498] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:11.498] if (!identical(...future.globals.maxSize.org,
[21:39:11.498] ...future.globals.maxSize)) {
[21:39:11.498] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:11.498] on.exit(options(oopts), add = TRUE)
[21:39:11.498] }
[21:39:11.498] {
[21:39:11.498] lapply(seq_along(...future.elements_ii),
[21:39:11.498] FUN = function(jj) {
[21:39:11.498] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:11.498] ...future.FUN(...future.X_jj, ...)
[21:39:11.498] })
[21:39:11.498] }
[21:39:11.498] }, args = future.call.arguments)
[21:39:11.498] }))
[21:39:11.498] future::FutureResult(value = ...future.value$value,
[21:39:11.498] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:11.498] ...future.rng), globalenv = if (FALSE)
[21:39:11.498] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:11.498] ...future.globalenv.names))
[21:39:11.498] else NULL, started = ...future.startTime, version = "1.8")
[21:39:11.498] }, condition = base::local({
[21:39:11.498] c <- base::c
[21:39:11.498] inherits <- base::inherits
[21:39:11.498] invokeRestart <- base::invokeRestart
[21:39:11.498] length <- base::length
[21:39:11.498] list <- base::list
[21:39:11.498] seq.int <- base::seq.int
[21:39:11.498] signalCondition <- base::signalCondition
[21:39:11.498] sys.calls <- base::sys.calls
[21:39:11.498] `[[` <- base::`[[`
[21:39:11.498] `+` <- base::`+`
[21:39:11.498] `<<-` <- base::`<<-`
[21:39:11.498] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:11.498] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:11.498] 3L)]
[21:39:11.498] }
[21:39:11.498] function(cond) {
[21:39:11.498] is_error <- inherits(cond, "error")
[21:39:11.498] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:11.498] NULL)
[21:39:11.498] if (is_error) {
[21:39:11.498] sessionInformation <- function() {
[21:39:11.498] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:11.498] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:11.498] search = base::search(), system = base::Sys.info())
[21:39:11.498] }
[21:39:11.498] ...future.conditions[[length(...future.conditions) +
[21:39:11.498] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:11.498] cond$call), session = sessionInformation(),
[21:39:11.498] timestamp = base::Sys.time(), signaled = 0L)
[21:39:11.498] signalCondition(cond)
[21:39:11.498] }
[21:39:11.498] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:11.498] "immediateCondition"))) {
[21:39:11.498] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:11.498] ...future.conditions[[length(...future.conditions) +
[21:39:11.498] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:11.498] if (TRUE && !signal) {
[21:39:11.498] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:11.498] {
[21:39:11.498] inherits <- base::inherits
[21:39:11.498] invokeRestart <- base::invokeRestart
[21:39:11.498] is.null <- base::is.null
[21:39:11.498] muffled <- FALSE
[21:39:11.498] if (inherits(cond, "message")) {
[21:39:11.498] muffled <- grepl(pattern, "muffleMessage")
[21:39:11.498] if (muffled)
[21:39:11.498] invokeRestart("muffleMessage")
[21:39:11.498] }
[21:39:11.498] else if (inherits(cond, "warning")) {
[21:39:11.498] muffled <- grepl(pattern, "muffleWarning")
[21:39:11.498] if (muffled)
[21:39:11.498] invokeRestart("muffleWarning")
[21:39:11.498] }
[21:39:11.498] else if (inherits(cond, "condition")) {
[21:39:11.498] if (!is.null(pattern)) {
[21:39:11.498] computeRestarts <- base::computeRestarts
[21:39:11.498] grepl <- base::grepl
[21:39:11.498] restarts <- computeRestarts(cond)
[21:39:11.498] for (restart in restarts) {
[21:39:11.498] name <- restart$name
[21:39:11.498] if (is.null(name))
[21:39:11.498] next
[21:39:11.498] if (!grepl(pattern, name))
[21:39:11.498] next
[21:39:11.498] invokeRestart(restart)
[21:39:11.498] muffled <- TRUE
[21:39:11.498] break
[21:39:11.498] }
[21:39:11.498] }
[21:39:11.498] }
[21:39:11.498] invisible(muffled)
[21:39:11.498] }
[21:39:11.498] muffleCondition(cond, pattern = "^muffle")
[21:39:11.498] }
[21:39:11.498] }
[21:39:11.498] else {
[21:39:11.498] if (TRUE) {
[21:39:11.498] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:11.498] {
[21:39:11.498] inherits <- base::inherits
[21:39:11.498] invokeRestart <- base::invokeRestart
[21:39:11.498] is.null <- base::is.null
[21:39:11.498] muffled <- FALSE
[21:39:11.498] if (inherits(cond, "message")) {
[21:39:11.498] muffled <- grepl(pattern, "muffleMessage")
[21:39:11.498] if (muffled)
[21:39:11.498] invokeRestart("muffleMessage")
[21:39:11.498] }
[21:39:11.498] else if (inherits(cond, "warning")) {
[21:39:11.498] muffled <- grepl(pattern, "muffleWarning")
[21:39:11.498] if (muffled)
[21:39:11.498] invokeRestart("muffleWarning")
[21:39:11.498] }
[21:39:11.498] else if (inherits(cond, "condition")) {
[21:39:11.498] if (!is.null(pattern)) {
[21:39:11.498] computeRestarts <- base::computeRestarts
[21:39:11.498] grepl <- base::grepl
[21:39:11.498] restarts <- computeRestarts(cond)
[21:39:11.498] for (restart in restarts) {
[21:39:11.498] name <- restart$name
[21:39:11.498] if (is.null(name))
[21:39:11.498] next
[21:39:11.498] if (!grepl(pattern, name))
[21:39:11.498] next
[21:39:11.498] invokeRestart(restart)
[21:39:11.498] muffled <- TRUE
[21:39:11.498] break
[21:39:11.498] }
[21:39:11.498] }
[21:39:11.498] }
[21:39:11.498] invisible(muffled)
[21:39:11.498] }
[21:39:11.498] muffleCondition(cond, pattern = "^muffle")
[21:39:11.498] }
[21:39:11.498] }
[21:39:11.498] }
[21:39:11.498] }))
[21:39:11.498] }, error = function(ex) {
[21:39:11.498] base::structure(base::list(value = NULL, visible = NULL,
[21:39:11.498] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:11.498] ...future.rng), started = ...future.startTime,
[21:39:11.498] finished = Sys.time(), session_uuid = NA_character_,
[21:39:11.498] version = "1.8"), class = "FutureResult")
[21:39:11.498] }, finally = {
[21:39:11.498] if (!identical(...future.workdir, getwd()))
[21:39:11.498] setwd(...future.workdir)
[21:39:11.498] {
[21:39:11.498] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:11.498] ...future.oldOptions$nwarnings <- NULL
[21:39:11.498] }
[21:39:11.498] base::options(...future.oldOptions)
[21:39:11.498] if (.Platform$OS.type == "windows") {
[21:39:11.498] old_names <- names(...future.oldEnvVars)
[21:39:11.498] envs <- base::Sys.getenv()
[21:39:11.498] names <- names(envs)
[21:39:11.498] common <- intersect(names, old_names)
[21:39:11.498] added <- setdiff(names, old_names)
[21:39:11.498] removed <- setdiff(old_names, names)
[21:39:11.498] changed <- common[...future.oldEnvVars[common] !=
[21:39:11.498] envs[common]]
[21:39:11.498] NAMES <- toupper(changed)
[21:39:11.498] args <- list()
[21:39:11.498] for (kk in seq_along(NAMES)) {
[21:39:11.498] name <- changed[[kk]]
[21:39:11.498] NAME <- NAMES[[kk]]
[21:39:11.498] if (name != NAME && is.element(NAME, old_names))
[21:39:11.498] next
[21:39:11.498] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:11.498] }
[21:39:11.498] NAMES <- toupper(added)
[21:39:11.498] for (kk in seq_along(NAMES)) {
[21:39:11.498] name <- added[[kk]]
[21:39:11.498] NAME <- NAMES[[kk]]
[21:39:11.498] if (name != NAME && is.element(NAME, old_names))
[21:39:11.498] next
[21:39:11.498] args[[name]] <- ""
[21:39:11.498] }
[21:39:11.498] NAMES <- toupper(removed)
[21:39:11.498] for (kk in seq_along(NAMES)) {
[21:39:11.498] name <- removed[[kk]]
[21:39:11.498] NAME <- NAMES[[kk]]
[21:39:11.498] if (name != NAME && is.element(NAME, old_names))
[21:39:11.498] next
[21:39:11.498] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:11.498] }
[21:39:11.498] if (length(args) > 0)
[21:39:11.498] base::do.call(base::Sys.setenv, args = args)
[21:39:11.498] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:11.498] }
[21:39:11.498] else {
[21:39:11.498] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:11.498] }
[21:39:11.498] {
[21:39:11.498] if (base::length(...future.futureOptionsAdded) >
[21:39:11.498] 0L) {
[21:39:11.498] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:11.498] base::names(opts) <- ...future.futureOptionsAdded
[21:39:11.498] base::options(opts)
[21:39:11.498] }
[21:39:11.498] {
[21:39:11.498] {
[21:39:11.498] NULL
[21:39:11.498] RNGkind("Mersenne-Twister")
[21:39:11.498] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:11.498] inherits = FALSE)
[21:39:11.498] }
[21:39:11.498] options(future.plan = NULL)
[21:39:11.498] if (is.na(NA_character_))
[21:39:11.498] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:11.498] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:11.498] future::plan(list(function (..., workers = availableCores(),
[21:39:11.498] lazy = FALSE, rscript_libs = .libPaths(),
[21:39:11.498] envir = parent.frame())
[21:39:11.498] {
[21:39:11.498] if (is.function(workers))
[21:39:11.498] workers <- workers()
[21:39:11.498] workers <- structure(as.integer(workers),
[21:39:11.498] class = class(workers))
[21:39:11.498] stop_if_not(length(workers) == 1, is.finite(workers),
[21:39:11.498] workers >= 1)
[21:39:11.498] if (workers == 1L && !inherits(workers, "AsIs")) {
[21:39:11.498] return(sequential(..., lazy = TRUE, envir = envir))
[21:39:11.498] }
[21:39:11.498] future <- MultisessionFuture(..., workers = workers,
[21:39:11.498] lazy = lazy, rscript_libs = rscript_libs,
[21:39:11.498] envir = envir)
[21:39:11.498] if (!future$lazy)
[21:39:11.498] future <- run(future)
[21:39:11.498] invisible(future)
[21:39:11.498] }), .cleanup = FALSE, .init = FALSE)
[21:39:11.498] }
[21:39:11.498] }
[21:39:11.498] }
[21:39:11.498] })
[21:39:11.498] if (FALSE) {
[21:39:11.498] base::sink(type = "output", split = FALSE)
[21:39:11.498] if (NA) {
[21:39:11.498] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:11.498] }
[21:39:11.498] else {
[21:39:11.498] ...future.result["stdout"] <- base::list(NULL)
[21:39:11.498] }
[21:39:11.498] base::close(...future.stdout)
[21:39:11.498] ...future.stdout <- NULL
[21:39:11.498] }
[21:39:11.498] ...future.result$conditions <- ...future.conditions
[21:39:11.498] ...future.result$finished <- base::Sys.time()
[21:39:11.498] ...future.result
[21:39:11.498] }
[21:39:11.502] assign_globals() ...
[21:39:11.519] List of 5
[21:39:11.519] $ ...future.FUN :function (x)
[21:39:11.519] $ future.call.arguments : list()
[21:39:11.519] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:11.519] $ ...future.elements_ii :List of 2
[21:39:11.519] ..$ : int 1
[21:39:11.519] ..$ : int 0
[21:39:11.519] $ ...future.seeds_ii : NULL
[21:39:11.519] $ ...future.globals.maxSize: NULL
[21:39:11.519] - attr(*, "resolved")= logi FALSE
[21:39:11.519] - attr(*, "total_size")= num 4720
[21:39:11.519] - attr(*, "where")=List of 5
[21:39:11.519] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:11.519] ..$ future.call.arguments :<environment: R_EmptyEnv>
[21:39:11.519] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:11.519] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:11.519] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:11.519] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:11.519] - attr(*, "already-done")= logi TRUE
[21:39:11.545] - reassign environment for '...future.FUN'
[21:39:11.545] - copied '...future.FUN' to environment
[21:39:11.545] - copied 'future.call.arguments' to environment
[21:39:11.545] - copied '...future.elements_ii' to environment
[21:39:11.545] - copied '...future.seeds_ii' to environment
[21:39:11.546] - copied '...future.globals.maxSize' to environment
[21:39:11.546] assign_globals() ... done
[21:39:11.547] plan(): Setting new future strategy stack:
[21:39:11.547] List of future strategies:
[21:39:11.547] 1. sequential:
[21:39:11.547] - args: function (..., envir = parent.frame())
[21:39:11.547] - tweaked: FALSE
[21:39:11.547] - call: NULL
[21:39:11.548] plan(): nbrOfWorkers() = 1
[21:39:12.050] plan(): Setting new future strategy stack:
[21:39:12.050] List of future strategies:
[21:39:12.050] 1. multisession:
[21:39:12.050] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[21:39:12.050] - tweaked: FALSE
[21:39:12.050] - call: plan(strategy)
[21:39:12.085] plan(): nbrOfWorkers() = 1
[21:39:12.086] SequentialFuture started (and completed)
[21:39:12.086] - Launch lazy future ... done
[21:39:12.086] run() for 'SequentialFuture' ... done
[21:39:12.086] Created future:
[21:39:12.087] SequentialFuture:
[21:39:12.087] Label: 'future_lapply-1'
[21:39:12.087] Expression:
[21:39:12.087] {
[21:39:12.087] do.call(function(...) {
[21:39:12.087] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:12.087] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:12.087] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:12.087] on.exit(options(oopts), add = TRUE)
[21:39:12.087] }
[21:39:12.087] {
[21:39:12.087] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:12.087] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:12.087] ...future.FUN(...future.X_jj, ...)
[21:39:12.087] })
[21:39:12.087] }
[21:39:12.087] }, args = future.call.arguments)
[21:39:12.087] }
[21:39:12.087] Lazy evaluation: FALSE
[21:39:12.087] Asynchronous evaluation: FALSE
[21:39:12.087] Local evaluation: TRUE
[21:39:12.087] Environment: R_GlobalEnv
[21:39:12.087] Capture standard output: NA
[21:39:12.087] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:12.087] Globals: 5 objects totaling 4.72 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:12.087] Packages: <none>
[21:39:12.087] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:12.087] Resolved: TRUE
[21:39:12.087] Value: 112 bytes of class 'list'
[21:39:12.087] Early signaling: FALSE
[21:39:12.087] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:12.087] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:12.089] Chunk #1 of 1 ... DONE
[21:39:12.089] Launching 1 futures (chunks) ... DONE
[21:39:12.089] Resolving 1 futures (chunks) ...
[21:39:12.090] resolve() on list ...
[21:39:12.090] recursive: 0
[21:39:12.090] length: 1
[21:39:12.090]
[21:39:12.090] resolved() for 'SequentialFuture' ...
[21:39:12.091] - state: 'finished'
[21:39:12.091] - run: TRUE
[21:39:12.091] - result: 'FutureResult'
[21:39:12.091] resolved() for 'SequentialFuture' ... done
[21:39:12.092] Future #1
[21:39:12.092] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:12.092] - nx: 1
[21:39:12.092] - relay: TRUE
[21:39:12.093] - stdout: TRUE
[21:39:12.093] - signal: TRUE
[21:39:12.093] - resignal: FALSE
[21:39:12.093] - force: TRUE
[21:39:12.093] - relayed: [n=1] FALSE
[21:39:12.094] - queued futures: [n=1] FALSE
[21:39:12.094] - until=1
[21:39:12.094] - relaying element #1
[21:39:12.095] - relayed: [n=1] TRUE
[21:39:12.095] - queued futures: [n=1] TRUE
[21:39:12.095] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:12.095] length: 0 (resolved future 1)
[21:39:12.096] Relaying remaining futures
[21:39:12.096] signalConditionsASAP(NULL, pos=0) ...
[21:39:12.096] - nx: 1
[21:39:12.096] - relay: TRUE
[21:39:12.096] - stdout: TRUE
[21:39:12.097] - signal: TRUE
[21:39:12.097] - resignal: FALSE
[21:39:12.097] - force: TRUE
[21:39:12.097] - relayed: [n=1] TRUE
[21:39:12.097] - queued futures: [n=1] TRUE
- flush all
[21:39:12.098] - relayed: [n=1] TRUE
[21:39:12.098] - queued futures: [n=1] TRUE
[21:39:12.098] signalConditionsASAP(NULL, pos=0) ... done
[21:39:12.115] resolve() on list ... DONE
[21:39:12.115] - Number of value chunks collected: 1
[21:39:12.115] Resolving 1 futures (chunks) ... DONE
[21:39:12.116] Reducing values from 1 chunks ...
[21:39:12.116] - Number of values collected after concatenation: 2
[21:39:12.116] - Number of values expected: 2
[21:39:12.116] Reducing values from 1 chunks ... DONE
[21:39:12.116] future_lapply() ... DONE
* future_lapply(x, ..., future.stdout = NA) ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ...
[21:39:12.117] future_mapply() ...
[21:39:12.177] Number of chunks: 1
[21:39:12.178] getGlobalsAndPackagesXApply() ...
[21:39:12.178] - future.globals: TRUE
[21:39:12.178] getGlobalsAndPackages() ...
[21:39:12.178] Searching for globals...
[21:39:12.182] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[21:39:12.182] Searching for globals ... DONE
[21:39:12.182] Resolving globals: FALSE
[21:39:12.183] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[21:39:12.184] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[21:39:12.184] - globals: [1] 'FUN'
[21:39:12.185]
[21:39:12.185] getGlobalsAndPackages() ... DONE
[21:39:12.185] - globals found/used: [n=1] 'FUN'
[21:39:12.185] - needed namespaces: [n=0]
[21:39:12.185] Finding globals ... DONE
[21:39:12.186] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[21:39:12.186] List of 2
[21:39:12.186] $ ...future.FUN:function (x, y)
[21:39:12.186] $ MoreArgs : NULL
[21:39:12.186] - attr(*, "where")=List of 2
[21:39:12.186] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:12.186] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:12.186] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:12.186] - attr(*, "resolved")= logi FALSE
[21:39:12.186] - attr(*, "total_size")= num NA
[21:39:12.220] Packages to be attached in all futures: [n=0]
[21:39:12.220] getGlobalsAndPackagesXApply() ... DONE
[21:39:12.221] Number of futures (= number of chunks): 1
[21:39:12.221] Launching 1 futures (chunks) ...
[21:39:12.221] Chunk #1 of 1 ...
[21:39:12.222] - Finding globals in '...' for chunk #1 ...
[21:39:12.222] getGlobalsAndPackages() ...
[21:39:12.222] Searching for globals...
[21:39:12.223]
[21:39:12.223] Searching for globals ... DONE
[21:39:12.223] - globals: [0] <none>
[21:39:12.223] getGlobalsAndPackages() ... DONE
[21:39:12.224] + additional globals found: [n=0]
[21:39:12.224] + additional namespaces needed: [n=0]
[21:39:12.224] - Finding globals in '...' for chunk #1 ... DONE
[21:39:12.224] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:12.225] - seeds: <none>
[21:39:12.225] getGlobalsAndPackages() ...
[21:39:12.225] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:12.225] Resolving globals: FALSE
[21:39:12.227] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[21:39:12.227] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[21:39:12.228] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:12.231]
[21:39:12.231] getGlobalsAndPackages() ... DONE
[21:39:12.232] run() for 'Future' ...
[21:39:12.232] - state: 'created'
[21:39:12.232] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[21:39:12.270] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:12.270] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:12.270] - Field: 'label'
[21:39:12.271] - Field: 'local'
[21:39:12.271] - Field: 'owner'
[21:39:12.271] - Field: 'envir'
[21:39:12.271] - Field: 'packages'
[21:39:12.272] - Field: 'gc'
[21:39:12.272] - Field: 'conditions'
[21:39:12.272] - Field: 'expr'
[21:39:12.272] - Field: 'uuid'
[21:39:12.272] - Field: 'seed'
[21:39:12.273] - Field: 'version'
[21:39:12.273] - Field: 'result'
[21:39:12.273] - Field: 'asynchronous'
[21:39:12.273] - Field: 'calls'
[21:39:12.274] - Field: 'globals'
[21:39:12.274] - Field: 'stdout'
[21:39:12.274] - Field: 'earlySignal'
[21:39:12.274] - Field: 'lazy'
[21:39:12.275] - Field: 'state'
[21:39:12.275] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:12.275] - Launch lazy future ...
[21:39:12.275] Packages needed by the future expression (n = 0): <none>
[21:39:12.276] Packages needed by future strategies (n = 0): <none>
[21:39:12.277] {
[21:39:12.277] {
[21:39:12.277] {
[21:39:12.277] ...future.startTime <- base::Sys.time()
[21:39:12.277] {
[21:39:12.277] {
[21:39:12.277] {
[21:39:12.277] base::local({
[21:39:12.277] has_future <- base::requireNamespace("future",
[21:39:12.277] quietly = TRUE)
[21:39:12.277] if (has_future) {
[21:39:12.277] ns <- base::getNamespace("future")
[21:39:12.277] version <- ns[[".package"]][["version"]]
[21:39:12.277] if (is.null(version))
[21:39:12.277] version <- utils::packageVersion("future")
[21:39:12.277] }
[21:39:12.277] else {
[21:39:12.277] version <- NULL
[21:39:12.277] }
[21:39:12.277] if (!has_future || version < "1.8.0") {
[21:39:12.277] info <- base::c(r_version = base::gsub("R version ",
[21:39:12.277] "", base::R.version$version.string),
[21:39:12.277] platform = base::sprintf("%s (%s-bit)",
[21:39:12.277] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:12.277] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:12.277] "release", "version")], collapse = " "),
[21:39:12.277] hostname = base::Sys.info()[["nodename"]])
[21:39:12.277] info <- base::sprintf("%s: %s", base::names(info),
[21:39:12.277] info)
[21:39:12.277] info <- base::paste(info, collapse = "; ")
[21:39:12.277] if (!has_future) {
[21:39:12.277] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:12.277] info)
[21:39:12.277] }
[21:39:12.277] else {
[21:39:12.277] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:12.277] info, version)
[21:39:12.277] }
[21:39:12.277] base::stop(msg)
[21:39:12.277] }
[21:39:12.277] })
[21:39:12.277] }
[21:39:12.277] options(future.plan = NULL)
[21:39:12.277] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:12.277] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:12.277] }
[21:39:12.277] ...future.workdir <- getwd()
[21:39:12.277] }
[21:39:12.277] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:12.277] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:12.277] }
[21:39:12.277] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:12.277] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:12.277] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:12.277] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:12.277] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:12.277] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:12.277] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:12.277] base::names(...future.oldOptions))
[21:39:12.277] }
[21:39:12.277] if (FALSE) {
[21:39:12.277] }
[21:39:12.277] else {
[21:39:12.277] if (FALSE) {
[21:39:12.277] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:12.277] open = "w")
[21:39:12.277] }
[21:39:12.277] else {
[21:39:12.277] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:12.277] windows = "NUL", "/dev/null"), open = "w")
[21:39:12.277] }
[21:39:12.277] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:12.277] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:12.277] base::sink(type = "output", split = FALSE)
[21:39:12.277] base::close(...future.stdout)
[21:39:12.277] }, add = TRUE)
[21:39:12.277] }
[21:39:12.277] ...future.frame <- base::sys.nframe()
[21:39:12.277] ...future.conditions <- base::list()
[21:39:12.277] ...future.rng <- base::globalenv()$.Random.seed
[21:39:12.277] if (FALSE) {
[21:39:12.277] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:12.277] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:12.277] }
[21:39:12.277] ...future.result <- base::tryCatch({
[21:39:12.277] base::withCallingHandlers({
[21:39:12.277] ...future.value <- base::withVisible(base::local({
[21:39:12.277] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:12.277] if (!identical(...future.globals.maxSize.org,
[21:39:12.277] ...future.globals.maxSize)) {
[21:39:12.277] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:12.277] on.exit(options(oopts), add = TRUE)
[21:39:12.277] }
[21:39:12.277] {
[21:39:12.277] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:12.277] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE,
[21:39:12.277] USE.NAMES = FALSE)
[21:39:12.277] do.call(mapply, args = args)
[21:39:12.277] }
[21:39:12.277] }))
[21:39:12.277] future::FutureResult(value = ...future.value$value,
[21:39:12.277] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:12.277] ...future.rng), globalenv = if (FALSE)
[21:39:12.277] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:12.277] ...future.globalenv.names))
[21:39:12.277] else NULL, started = ...future.startTime, version = "1.8")
[21:39:12.277] }, condition = base::local({
[21:39:12.277] c <- base::c
[21:39:12.277] inherits <- base::inherits
[21:39:12.277] invokeRestart <- base::invokeRestart
[21:39:12.277] length <- base::length
[21:39:12.277] list <- base::list
[21:39:12.277] seq.int <- base::seq.int
[21:39:12.277] signalCondition <- base::signalCondition
[21:39:12.277] sys.calls <- base::sys.calls
[21:39:12.277] `[[` <- base::`[[`
[21:39:12.277] `+` <- base::`+`
[21:39:12.277] `<<-` <- base::`<<-`
[21:39:12.277] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:12.277] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:12.277] 3L)]
[21:39:12.277] }
[21:39:12.277] function(cond) {
[21:39:12.277] is_error <- inherits(cond, "error")
[21:39:12.277] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:12.277] NULL)
[21:39:12.277] if (is_error) {
[21:39:12.277] sessionInformation <- function() {
[21:39:12.277] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:12.277] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:12.277] search = base::search(), system = base::Sys.info())
[21:39:12.277] }
[21:39:12.277] ...future.conditions[[length(...future.conditions) +
[21:39:12.277] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:12.277] cond$call), session = sessionInformation(),
[21:39:12.277] timestamp = base::Sys.time(), signaled = 0L)
[21:39:12.277] signalCondition(cond)
[21:39:12.277] }
[21:39:12.277] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:12.277] "immediateCondition"))) {
[21:39:12.277] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:12.277] ...future.conditions[[length(...future.conditions) +
[21:39:12.277] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:12.277] if (TRUE && !signal) {
[21:39:12.277] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:12.277] {
[21:39:12.277] inherits <- base::inherits
[21:39:12.277] invokeRestart <- base::invokeRestart
[21:39:12.277] is.null <- base::is.null
[21:39:12.277] muffled <- FALSE
[21:39:12.277] if (inherits(cond, "message")) {
[21:39:12.277] muffled <- grepl(pattern, "muffleMessage")
[21:39:12.277] if (muffled)
[21:39:12.277] invokeRestart("muffleMessage")
[21:39:12.277] }
[21:39:12.277] else if (inherits(cond, "warning")) {
[21:39:12.277] muffled <- grepl(pattern, "muffleWarning")
[21:39:12.277] if (muffled)
[21:39:12.277] invokeRestart("muffleWarning")
[21:39:12.277] }
[21:39:12.277] else if (inherits(cond, "condition")) {
[21:39:12.277] if (!is.null(pattern)) {
[21:39:12.277] computeRestarts <- base::computeRestarts
[21:39:12.277] grepl <- base::grepl
[21:39:12.277] restarts <- computeRestarts(cond)
[21:39:12.277] for (restart in restarts) {
[21:39:12.277] name <- restart$name
[21:39:12.277] if (is.null(name))
[21:39:12.277] next
[21:39:12.277] if (!grepl(pattern, name))
[21:39:12.277] next
[21:39:12.277] invokeRestart(restart)
[21:39:12.277] muffled <- TRUE
[21:39:12.277] break
[21:39:12.277] }
[21:39:12.277] }
[21:39:12.277] }
[21:39:12.277] invisible(muffled)
[21:39:12.277] }
[21:39:12.277] muffleCondition(cond, pattern = "^muffle")
[21:39:12.277] }
[21:39:12.277] }
[21:39:12.277] else {
[21:39:12.277] if (TRUE) {
[21:39:12.277] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:12.277] {
[21:39:12.277] inherits <- base::inherits
[21:39:12.277] invokeRestart <- base::invokeRestart
[21:39:12.277] is.null <- base::is.null
[21:39:12.277] muffled <- FALSE
[21:39:12.277] if (inherits(cond, "message")) {
[21:39:12.277] muffled <- grepl(pattern, "muffleMessage")
[21:39:12.277] if (muffled)
[21:39:12.277] invokeRestart("muffleMessage")
[21:39:12.277] }
[21:39:12.277] else if (inherits(cond, "warning")) {
[21:39:12.277] muffled <- grepl(pattern, "muffleWarning")
[21:39:12.277] if (muffled)
[21:39:12.277] invokeRestart("muffleWarning")
[21:39:12.277] }
[21:39:12.277] else if (inherits(cond, "condition")) {
[21:39:12.277] if (!is.null(pattern)) {
[21:39:12.277] computeRestarts <- base::computeRestarts
[21:39:12.277] grepl <- base::grepl
[21:39:12.277] restarts <- computeRestarts(cond)
[21:39:12.277] for (restart in restarts) {
[21:39:12.277] name <- restart$name
[21:39:12.277] if (is.null(name))
[21:39:12.277] next
[21:39:12.277] if (!grepl(pattern, name))
[21:39:12.277] next
[21:39:12.277] invokeRestart(restart)
[21:39:12.277] muffled <- TRUE
[21:39:12.277] break
[21:39:12.277] }
[21:39:12.277] }
[21:39:12.277] }
[21:39:12.277] invisible(muffled)
[21:39:12.277] }
[21:39:12.277] muffleCondition(cond, pattern = "^muffle")
[21:39:12.277] }
[21:39:12.277] }
[21:39:12.277] }
[21:39:12.277] }))
[21:39:12.277] }, error = function(ex) {
[21:39:12.277] base::structure(base::list(value = NULL, visible = NULL,
[21:39:12.277] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:12.277] ...future.rng), started = ...future.startTime,
[21:39:12.277] finished = Sys.time(), session_uuid = NA_character_,
[21:39:12.277] version = "1.8"), class = "FutureResult")
[21:39:12.277] }, finally = {
[21:39:12.277] if (!identical(...future.workdir, getwd()))
[21:39:12.277] setwd(...future.workdir)
[21:39:12.277] {
[21:39:12.277] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:12.277] ...future.oldOptions$nwarnings <- NULL
[21:39:12.277] }
[21:39:12.277] base::options(...future.oldOptions)
[21:39:12.277] if (.Platform$OS.type == "windows") {
[21:39:12.277] old_names <- names(...future.oldEnvVars)
[21:39:12.277] envs <- base::Sys.getenv()
[21:39:12.277] names <- names(envs)
[21:39:12.277] common <- intersect(names, old_names)
[21:39:12.277] added <- setdiff(names, old_names)
[21:39:12.277] removed <- setdiff(old_names, names)
[21:39:12.277] changed <- common[...future.oldEnvVars[common] !=
[21:39:12.277] envs[common]]
[21:39:12.277] NAMES <- toupper(changed)
[21:39:12.277] args <- list()
[21:39:12.277] for (kk in seq_along(NAMES)) {
[21:39:12.277] name <- changed[[kk]]
[21:39:12.277] NAME <- NAMES[[kk]]
[21:39:12.277] if (name != NAME && is.element(NAME, old_names))
[21:39:12.277] next
[21:39:12.277] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:12.277] }
[21:39:12.277] NAMES <- toupper(added)
[21:39:12.277] for (kk in seq_along(NAMES)) {
[21:39:12.277] name <- added[[kk]]
[21:39:12.277] NAME <- NAMES[[kk]]
[21:39:12.277] if (name != NAME && is.element(NAME, old_names))
[21:39:12.277] next
[21:39:12.277] args[[name]] <- ""
[21:39:12.277] }
[21:39:12.277] NAMES <- toupper(removed)
[21:39:12.277] for (kk in seq_along(NAMES)) {
[21:39:12.277] name <- removed[[kk]]
[21:39:12.277] NAME <- NAMES[[kk]]
[21:39:12.277] if (name != NAME && is.element(NAME, old_names))
[21:39:12.277] next
[21:39:12.277] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:12.277] }
[21:39:12.277] if (length(args) > 0)
[21:39:12.277] base::do.call(base::Sys.setenv, args = args)
[21:39:12.277] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:12.277] }
[21:39:12.277] else {
[21:39:12.277] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:12.277] }
[21:39:12.277] {
[21:39:12.277] if (base::length(...future.futureOptionsAdded) >
[21:39:12.277] 0L) {
[21:39:12.277] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:12.277] base::names(opts) <- ...future.futureOptionsAdded
[21:39:12.277] base::options(opts)
[21:39:12.277] }
[21:39:12.277] {
[21:39:12.277] {
[21:39:12.277] NULL
[21:39:12.277] RNGkind("Mersenne-Twister")
[21:39:12.277] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:12.277] inherits = FALSE)
[21:39:12.277] }
[21:39:12.277] options(future.plan = NULL)
[21:39:12.277] if (is.na(NA_character_))
[21:39:12.277] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:12.277] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:12.277] future::plan(list(function (..., workers = availableCores(),
[21:39:12.277] lazy = FALSE, rscript_libs = .libPaths(),
[21:39:12.277] envir = parent.frame())
[21:39:12.277] {
[21:39:12.277] if (is.function(workers))
[21:39:12.277] workers <- workers()
[21:39:12.277] workers <- structure(as.integer(workers),
[21:39:12.277] class = class(workers))
[21:39:12.277] stop_if_not(length(workers) == 1, is.finite(workers),
[21:39:12.277] workers >= 1)
[21:39:12.277] if (workers == 1L && !inherits(workers, "AsIs")) {
[21:39:12.277] return(sequential(..., lazy = TRUE, envir = envir))
[21:39:12.277] }
[21:39:12.277] future <- MultisessionFuture(..., workers = workers,
[21:39:12.277] lazy = lazy, rscript_libs = rscript_libs,
[21:39:12.277] envir = envir)
[21:39:12.277] if (!future$lazy)
[21:39:12.277] future <- run(future)
[21:39:12.277] invisible(future)
[21:39:12.277] }), .cleanup = FALSE, .init = FALSE)
[21:39:12.277] }
[21:39:12.277] }
[21:39:12.277] }
[21:39:12.277] })
[21:39:12.277] if (TRUE) {
[21:39:12.277] base::sink(type = "output", split = FALSE)
[21:39:12.277] if (FALSE) {
[21:39:12.277] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:12.277] }
[21:39:12.277] else {
[21:39:12.277] ...future.result["stdout"] <- base::list(NULL)
[21:39:12.277] }
[21:39:12.277] base::close(...future.stdout)
[21:39:12.277] ...future.stdout <- NULL
[21:39:12.277] }
[21:39:12.277] ...future.result$conditions <- ...future.conditions
[21:39:12.277] ...future.result$finished <- base::Sys.time()
[21:39:12.277] ...future.result
[21:39:12.277] }
[21:39:12.280] assign_globals() ...
[21:39:12.281] List of 5
[21:39:12.281] $ ...future.FUN :function (x, y)
[21:39:12.281] $ MoreArgs : NULL
[21:39:12.281] $ ...future.elements_ii :List of 2
[21:39:12.281] ..$ :List of 2
[21:39:12.281] .. ..$ : int 1
[21:39:12.281] .. ..$ : int 0
[21:39:12.281] ..$ :List of 2
[21:39:12.281] .. ..$ : int 0
[21:39:12.281] .. ..$ : int 1
[21:39:12.281] $ ...future.seeds_ii : NULL
[21:39:12.281] $ ...future.globals.maxSize: NULL
[21:39:12.281] - attr(*, "resolved")= logi FALSE
[21:39:12.281] - attr(*, "total_size")= num 6480
[21:39:12.281] - attr(*, "where")=List of 5
[21:39:12.281] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:12.281] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:12.281] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:12.281] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:12.281] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:12.281] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:12.281] - attr(*, "already-done")= logi TRUE
[21:39:12.310] - reassign environment for '...future.FUN'
[21:39:12.310] - copied '...future.FUN' to environment
[21:39:12.310] - copied 'MoreArgs' to environment
[21:39:12.310] - copied '...future.elements_ii' to environment
[21:39:12.311] - copied '...future.seeds_ii' to environment
[21:39:12.311] - copied '...future.globals.maxSize' to environment
[21:39:12.311] assign_globals() ... done
[21:39:12.312] plan(): Setting new future strategy stack:
[21:39:12.312] List of future strategies:
[21:39:12.312] 1. sequential:
[21:39:12.312] - args: function (..., envir = parent.frame())
[21:39:12.312] - tweaked: FALSE
[21:39:12.312] - call: NULL
[21:39:12.313] plan(): nbrOfWorkers() = 1
[21:39:12.815] plan(): Setting new future strategy stack:
[21:39:12.815] List of future strategies:
[21:39:12.815] 1. multisession:
[21:39:12.815] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[21:39:12.815] - tweaked: FALSE
[21:39:12.815] - call: plan(strategy)
[21:39:12.870] plan(): nbrOfWorkers() = 1
[21:39:12.870] SequentialFuture started (and completed)
[21:39:12.870] - Launch lazy future ... done
[21:39:12.871] run() for 'SequentialFuture' ... done
[21:39:12.871] Created future:
[21:39:12.871] SequentialFuture:
[21:39:12.871] Label: 'future_mapply-1'
[21:39:12.871] Expression:
[21:39:12.871] {
[21:39:12.871] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:12.871] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:12.871] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:12.871] on.exit(options(oopts), add = TRUE)
[21:39:12.871] }
[21:39:12.871] {
[21:39:12.871] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:12.871] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[21:39:12.871] do.call(mapply, args = args)
[21:39:12.871] }
[21:39:12.871] }
[21:39:12.871] Lazy evaluation: FALSE
[21:39:12.871] Asynchronous evaluation: FALSE
[21:39:12.871] Local evaluation: TRUE
[21:39:12.871] Environment: R_GlobalEnv
[21:39:12.871] Capture standard output: FALSE
[21:39:12.871] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:12.871] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:12.871] Packages: <none>
[21:39:12.871] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:12.871] Resolved: TRUE
[21:39:12.871] Value: 224 bytes of class 'list'
[21:39:12.871] Early signaling: FALSE
[21:39:12.871] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:12.871] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:12.873] Chunk #1 of 1 ... DONE
[21:39:12.874] Launching 1 futures (chunks) ... DONE
[21:39:12.874] Resolving 1 futures (chunks) ...
[21:39:12.874] resolve() on list ...
[21:39:12.874] recursive: 0
[21:39:12.874] length: 1
[21:39:12.875]
[21:39:12.875] resolved() for 'SequentialFuture' ...
[21:39:12.875] - state: 'finished'
[21:39:12.875] - run: TRUE
[21:39:12.876] - result: 'FutureResult'
[21:39:12.876] resolved() for 'SequentialFuture' ... done
[21:39:12.876] Future #1
[21:39:12.876] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:12.877] - nx: 1
[21:39:12.877] - relay: TRUE
[21:39:12.877] - stdout: TRUE
[21:39:12.877] - signal: TRUE
[21:39:12.877] - resignal: FALSE
[21:39:12.877] - force: TRUE
[21:39:12.878] - relayed: [n=1] FALSE
[21:39:12.878] - queued futures: [n=1] FALSE
[21:39:12.878] - until=1
[21:39:12.878] - relaying element #1
[21:39:12.879] - relayed: [n=1] TRUE
[21:39:12.879] - queued futures: [n=1] TRUE
[21:39:12.879] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:12.879] length: 0 (resolved future 1)
[21:39:12.880] Relaying remaining futures
[21:39:12.880] signalConditionsASAP(NULL, pos=0) ...
[21:39:12.880] - nx: 1
[21:39:12.880] - relay: TRUE
[21:39:12.880] - stdout: TRUE
[21:39:12.881] - signal: TRUE
[21:39:12.881] - resignal: FALSE
[21:39:12.881] - force: TRUE
[21:39:12.881] - relayed: [n=1] TRUE
[21:39:12.881] - queued futures: [n=1] TRUE
- flush all
[21:39:12.882] - relayed: [n=1] TRUE
[21:39:12.882] - queued futures: [n=1] TRUE
[21:39:12.882] signalConditionsASAP(NULL, pos=0) ... done
[21:39:12.882] resolve() on list ... DONE
[21:39:12.895] - Number of value chunks collected: 1
[21:39:12.895] Resolving 1 futures (chunks) ... DONE
[21:39:12.895] Reducing values from 1 chunks ...
[21:39:12.896] - Number of values collected after concatenation: 2
[21:39:12.896] - Number of values expected: 2
[21:39:12.896] Reducing values from 1 chunks ... DONE
[21:39:12.896] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = FALSE) ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ...
[21:39:12.897] future_mapply() ...
[21:39:12.949] Number of chunks: 1
[21:39:12.949] getGlobalsAndPackagesXApply() ...
[21:39:12.950] - future.globals: TRUE
[21:39:12.950] getGlobalsAndPackages() ...
[21:39:12.950] Searching for globals...
[21:39:12.954] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[21:39:12.955] Searching for globals ... DONE
[21:39:12.955] Resolving globals: FALSE
[21:39:12.956] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[21:39:12.957] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[21:39:12.957] - globals: [1] 'FUN'
[21:39:12.957]
[21:39:12.958] getGlobalsAndPackages() ... DONE
[21:39:12.958] - globals found/used: [n=1] 'FUN'
[21:39:12.958] - needed namespaces: [n=0]
[21:39:12.971] Finding globals ... DONE
[21:39:12.971] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[21:39:12.971] List of 2
[21:39:12.971] $ ...future.FUN:function (x, y)
[21:39:12.971] $ MoreArgs : NULL
[21:39:12.971] - attr(*, "where")=List of 2
[21:39:12.971] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:12.971] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:12.971] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:12.971] - attr(*, "resolved")= logi FALSE
[21:39:12.971] - attr(*, "total_size")= num NA
[21:39:12.977] Packages to be attached in all futures: [n=0]
[21:39:12.978] getGlobalsAndPackagesXApply() ... DONE
[21:39:12.978] Number of futures (= number of chunks): 1
[21:39:12.979] Launching 1 futures (chunks) ...
[21:39:12.979] Chunk #1 of 1 ...
[21:39:12.979] - Finding globals in '...' for chunk #1 ...
[21:39:12.979] getGlobalsAndPackages() ...
[21:39:12.980] Searching for globals...
[21:39:12.980]
[21:39:12.981] Searching for globals ... DONE
[21:39:12.981] - globals: [0] <none>
[21:39:12.981] getGlobalsAndPackages() ... DONE
[21:39:12.981] + additional globals found: [n=0]
[21:39:12.982] + additional namespaces needed: [n=0]
[21:39:12.982] - Finding globals in '...' for chunk #1 ... DONE
[21:39:12.982] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:12.999] - seeds: <none>
[21:39:12.999] getGlobalsAndPackages() ...
[21:39:12.999] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:13.000] Resolving globals: FALSE
[21:39:13.001] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[21:39:13.002] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[21:39:13.002] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:13.002]
[21:39:13.002] getGlobalsAndPackages() ... DONE
[21:39:13.003] run() for 'Future' ...
[21:39:13.003] - state: 'created'
[21:39:13.004] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[21:39:13.076] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:13.077] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:13.077] - Field: 'label'
[21:39:13.077] - Field: 'local'
[21:39:13.077] - Field: 'owner'
[21:39:13.078] - Field: 'envir'
[21:39:13.078] - Field: 'packages'
[21:39:13.078] - Field: 'gc'
[21:39:13.078] - Field: 'conditions'
[21:39:13.079] - Field: 'expr'
[21:39:13.079] - Field: 'uuid'
[21:39:13.079] - Field: 'seed'
[21:39:13.079] - Field: 'version'
[21:39:13.080] - Field: 'result'
[21:39:13.080] - Field: 'asynchronous'
[21:39:13.080] - Field: 'calls'
[21:39:13.080] - Field: 'globals'
[21:39:13.080] - Field: 'stdout'
[21:39:13.081] - Field: 'earlySignal'
[21:39:13.081] - Field: 'lazy'
[21:39:13.081] - Field: 'state'
[21:39:13.081] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:13.082] - Launch lazy future ...
[21:39:13.082] Packages needed by the future expression (n = 0): <none>
[21:39:13.082] Packages needed by future strategies (n = 0): <none>
[21:39:13.083] {
[21:39:13.083] {
[21:39:13.083] {
[21:39:13.083] ...future.startTime <- base::Sys.time()
[21:39:13.083] {
[21:39:13.083] {
[21:39:13.083] {
[21:39:13.083] base::local({
[21:39:13.083] has_future <- base::requireNamespace("future",
[21:39:13.083] quietly = TRUE)
[21:39:13.083] if (has_future) {
[21:39:13.083] ns <- base::getNamespace("future")
[21:39:13.083] version <- ns[[".package"]][["version"]]
[21:39:13.083] if (is.null(version))
[21:39:13.083] version <- utils::packageVersion("future")
[21:39:13.083] }
[21:39:13.083] else {
[21:39:13.083] version <- NULL
[21:39:13.083] }
[21:39:13.083] if (!has_future || version < "1.8.0") {
[21:39:13.083] info <- base::c(r_version = base::gsub("R version ",
[21:39:13.083] "", base::R.version$version.string),
[21:39:13.083] platform = base::sprintf("%s (%s-bit)",
[21:39:13.083] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:13.083] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:13.083] "release", "version")], collapse = " "),
[21:39:13.083] hostname = base::Sys.info()[["nodename"]])
[21:39:13.083] info <- base::sprintf("%s: %s", base::names(info),
[21:39:13.083] info)
[21:39:13.083] info <- base::paste(info, collapse = "; ")
[21:39:13.083] if (!has_future) {
[21:39:13.083] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:13.083] info)
[21:39:13.083] }
[21:39:13.083] else {
[21:39:13.083] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:13.083] info, version)
[21:39:13.083] }
[21:39:13.083] base::stop(msg)
[21:39:13.083] }
[21:39:13.083] })
[21:39:13.083] }
[21:39:13.083] options(future.plan = NULL)
[21:39:13.083] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:13.083] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:13.083] }
[21:39:13.083] ...future.workdir <- getwd()
[21:39:13.083] }
[21:39:13.083] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:13.083] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:13.083] }
[21:39:13.083] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:13.083] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:13.083] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:13.083] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:13.083] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:13.083] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:13.083] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:13.083] base::names(...future.oldOptions))
[21:39:13.083] }
[21:39:13.083] if (FALSE) {
[21:39:13.083] }
[21:39:13.083] else {
[21:39:13.083] if (TRUE) {
[21:39:13.083] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:13.083] open = "w")
[21:39:13.083] }
[21:39:13.083] else {
[21:39:13.083] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:13.083] windows = "NUL", "/dev/null"), open = "w")
[21:39:13.083] }
[21:39:13.083] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:13.083] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:13.083] base::sink(type = "output", split = FALSE)
[21:39:13.083] base::close(...future.stdout)
[21:39:13.083] }, add = TRUE)
[21:39:13.083] }
[21:39:13.083] ...future.frame <- base::sys.nframe()
[21:39:13.083] ...future.conditions <- base::list()
[21:39:13.083] ...future.rng <- base::globalenv()$.Random.seed
[21:39:13.083] if (FALSE) {
[21:39:13.083] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:13.083] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:13.083] }
[21:39:13.083] ...future.result <- base::tryCatch({
[21:39:13.083] base::withCallingHandlers({
[21:39:13.083] ...future.value <- base::withVisible(base::local({
[21:39:13.083] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:13.083] if (!identical(...future.globals.maxSize.org,
[21:39:13.083] ...future.globals.maxSize)) {
[21:39:13.083] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:13.083] on.exit(options(oopts), add = TRUE)
[21:39:13.083] }
[21:39:13.083] {
[21:39:13.083] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:13.083] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE,
[21:39:13.083] USE.NAMES = FALSE)
[21:39:13.083] do.call(mapply, args = args)
[21:39:13.083] }
[21:39:13.083] }))
[21:39:13.083] future::FutureResult(value = ...future.value$value,
[21:39:13.083] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:13.083] ...future.rng), globalenv = if (FALSE)
[21:39:13.083] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:13.083] ...future.globalenv.names))
[21:39:13.083] else NULL, started = ...future.startTime, version = "1.8")
[21:39:13.083] }, condition = base::local({
[21:39:13.083] c <- base::c
[21:39:13.083] inherits <- base::inherits
[21:39:13.083] invokeRestart <- base::invokeRestart
[21:39:13.083] length <- base::length
[21:39:13.083] list <- base::list
[21:39:13.083] seq.int <- base::seq.int
[21:39:13.083] signalCondition <- base::signalCondition
[21:39:13.083] sys.calls <- base::sys.calls
[21:39:13.083] `[[` <- base::`[[`
[21:39:13.083] `+` <- base::`+`
[21:39:13.083] `<<-` <- base::`<<-`
[21:39:13.083] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:13.083] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:13.083] 3L)]
[21:39:13.083] }
[21:39:13.083] function(cond) {
[21:39:13.083] is_error <- inherits(cond, "error")
[21:39:13.083] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:13.083] NULL)
[21:39:13.083] if (is_error) {
[21:39:13.083] sessionInformation <- function() {
[21:39:13.083] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:13.083] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:13.083] search = base::search(), system = base::Sys.info())
[21:39:13.083] }
[21:39:13.083] ...future.conditions[[length(...future.conditions) +
[21:39:13.083] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:13.083] cond$call), session = sessionInformation(),
[21:39:13.083] timestamp = base::Sys.time(), signaled = 0L)
[21:39:13.083] signalCondition(cond)
[21:39:13.083] }
[21:39:13.083] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:13.083] "immediateCondition"))) {
[21:39:13.083] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:13.083] ...future.conditions[[length(...future.conditions) +
[21:39:13.083] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:13.083] if (TRUE && !signal) {
[21:39:13.083] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:13.083] {
[21:39:13.083] inherits <- base::inherits
[21:39:13.083] invokeRestart <- base::invokeRestart
[21:39:13.083] is.null <- base::is.null
[21:39:13.083] muffled <- FALSE
[21:39:13.083] if (inherits(cond, "message")) {
[21:39:13.083] muffled <- grepl(pattern, "muffleMessage")
[21:39:13.083] if (muffled)
[21:39:13.083] invokeRestart("muffleMessage")
[21:39:13.083] }
[21:39:13.083] else if (inherits(cond, "warning")) {
[21:39:13.083] muffled <- grepl(pattern, "muffleWarning")
[21:39:13.083] if (muffled)
[21:39:13.083] invokeRestart("muffleWarning")
[21:39:13.083] }
[21:39:13.083] else if (inherits(cond, "condition")) {
[21:39:13.083] if (!is.null(pattern)) {
[21:39:13.083] computeRestarts <- base::computeRestarts
[21:39:13.083] grepl <- base::grepl
[21:39:13.083] restarts <- computeRestarts(cond)
[21:39:13.083] for (restart in restarts) {
[21:39:13.083] name <- restart$name
[21:39:13.083] if (is.null(name))
[21:39:13.083] next
[21:39:13.083] if (!grepl(pattern, name))
[21:39:13.083] next
[21:39:13.083] invokeRestart(restart)
[21:39:13.083] muffled <- TRUE
[21:39:13.083] break
[21:39:13.083] }
[21:39:13.083] }
[21:39:13.083] }
[21:39:13.083] invisible(muffled)
[21:39:13.083] }
[21:39:13.083] muffleCondition(cond, pattern = "^muffle")
[21:39:13.083] }
[21:39:13.083] }
[21:39:13.083] else {
[21:39:13.083] if (TRUE) {
[21:39:13.083] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:13.083] {
[21:39:13.083] inherits <- base::inherits
[21:39:13.083] invokeRestart <- base::invokeRestart
[21:39:13.083] is.null <- base::is.null
[21:39:13.083] muffled <- FALSE
[21:39:13.083] if (inherits(cond, "message")) {
[21:39:13.083] muffled <- grepl(pattern, "muffleMessage")
[21:39:13.083] if (muffled)
[21:39:13.083] invokeRestart("muffleMessage")
[21:39:13.083] }
[21:39:13.083] else if (inherits(cond, "warning")) {
[21:39:13.083] muffled <- grepl(pattern, "muffleWarning")
[21:39:13.083] if (muffled)
[21:39:13.083] invokeRestart("muffleWarning")
[21:39:13.083] }
[21:39:13.083] else if (inherits(cond, "condition")) {
[21:39:13.083] if (!is.null(pattern)) {
[21:39:13.083] computeRestarts <- base::computeRestarts
[21:39:13.083] grepl <- base::grepl
[21:39:13.083] restarts <- computeRestarts(cond)
[21:39:13.083] for (restart in restarts) {
[21:39:13.083] name <- restart$name
[21:39:13.083] if (is.null(name))
[21:39:13.083] next
[21:39:13.083] if (!grepl(pattern, name))
[21:39:13.083] next
[21:39:13.083] invokeRestart(restart)
[21:39:13.083] muffled <- TRUE
[21:39:13.083] break
[21:39:13.083] }
[21:39:13.083] }
[21:39:13.083] }
[21:39:13.083] invisible(muffled)
[21:39:13.083] }
[21:39:13.083] muffleCondition(cond, pattern = "^muffle")
[21:39:13.083] }
[21:39:13.083] }
[21:39:13.083] }
[21:39:13.083] }))
[21:39:13.083] }, error = function(ex) {
[21:39:13.083] base::structure(base::list(value = NULL, visible = NULL,
[21:39:13.083] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:13.083] ...future.rng), started = ...future.startTime,
[21:39:13.083] finished = Sys.time(), session_uuid = NA_character_,
[21:39:13.083] version = "1.8"), class = "FutureResult")
[21:39:13.083] }, finally = {
[21:39:13.083] if (!identical(...future.workdir, getwd()))
[21:39:13.083] setwd(...future.workdir)
[21:39:13.083] {
[21:39:13.083] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:13.083] ...future.oldOptions$nwarnings <- NULL
[21:39:13.083] }
[21:39:13.083] base::options(...future.oldOptions)
[21:39:13.083] if (.Platform$OS.type == "windows") {
[21:39:13.083] old_names <- names(...future.oldEnvVars)
[21:39:13.083] envs <- base::Sys.getenv()
[21:39:13.083] names <- names(envs)
[21:39:13.083] common <- intersect(names, old_names)
[21:39:13.083] added <- setdiff(names, old_names)
[21:39:13.083] removed <- setdiff(old_names, names)
[21:39:13.083] changed <- common[...future.oldEnvVars[common] !=
[21:39:13.083] envs[common]]
[21:39:13.083] NAMES <- toupper(changed)
[21:39:13.083] args <- list()
[21:39:13.083] for (kk in seq_along(NAMES)) {
[21:39:13.083] name <- changed[[kk]]
[21:39:13.083] NAME <- NAMES[[kk]]
[21:39:13.083] if (name != NAME && is.element(NAME, old_names))
[21:39:13.083] next
[21:39:13.083] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:13.083] }
[21:39:13.083] NAMES <- toupper(added)
[21:39:13.083] for (kk in seq_along(NAMES)) {
[21:39:13.083] name <- added[[kk]]
[21:39:13.083] NAME <- NAMES[[kk]]
[21:39:13.083] if (name != NAME && is.element(NAME, old_names))
[21:39:13.083] next
[21:39:13.083] args[[name]] <- ""
[21:39:13.083] }
[21:39:13.083] NAMES <- toupper(removed)
[21:39:13.083] for (kk in seq_along(NAMES)) {
[21:39:13.083] name <- removed[[kk]]
[21:39:13.083] NAME <- NAMES[[kk]]
[21:39:13.083] if (name != NAME && is.element(NAME, old_names))
[21:39:13.083] next
[21:39:13.083] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:13.083] }
[21:39:13.083] if (length(args) > 0)
[21:39:13.083] base::do.call(base::Sys.setenv, args = args)
[21:39:13.083] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:13.083] }
[21:39:13.083] else {
[21:39:13.083] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:13.083] }
[21:39:13.083] {
[21:39:13.083] if (base::length(...future.futureOptionsAdded) >
[21:39:13.083] 0L) {
[21:39:13.083] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:13.083] base::names(opts) <- ...future.futureOptionsAdded
[21:39:13.083] base::options(opts)
[21:39:13.083] }
[21:39:13.083] {
[21:39:13.083] {
[21:39:13.083] NULL
[21:39:13.083] RNGkind("Mersenne-Twister")
[21:39:13.083] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:13.083] inherits = FALSE)
[21:39:13.083] }
[21:39:13.083] options(future.plan = NULL)
[21:39:13.083] if (is.na(NA_character_))
[21:39:13.083] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:13.083] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:13.083] future::plan(list(function (..., workers = availableCores(),
[21:39:13.083] lazy = FALSE, rscript_libs = .libPaths(),
[21:39:13.083] envir = parent.frame())
[21:39:13.083] {
[21:39:13.083] if (is.function(workers))
[21:39:13.083] workers <- workers()
[21:39:13.083] workers <- structure(as.integer(workers),
[21:39:13.083] class = class(workers))
[21:39:13.083] stop_if_not(length(workers) == 1, is.finite(workers),
[21:39:13.083] workers >= 1)
[21:39:13.083] if (workers == 1L && !inherits(workers, "AsIs")) {
[21:39:13.083] return(sequential(..., lazy = TRUE, envir = envir))
[21:39:13.083] }
[21:39:13.083] future <- MultisessionFuture(..., workers = workers,
[21:39:13.083] lazy = lazy, rscript_libs = rscript_libs,
[21:39:13.083] envir = envir)
[21:39:13.083] if (!future$lazy)
[21:39:13.083] future <- run(future)
[21:39:13.083] invisible(future)
[21:39:13.083] }), .cleanup = FALSE, .init = FALSE)
[21:39:13.083] }
[21:39:13.083] }
[21:39:13.083] }
[21:39:13.083] })
[21:39:13.083] if (TRUE) {
[21:39:13.083] base::sink(type = "output", split = FALSE)
[21:39:13.083] if (TRUE) {
[21:39:13.083] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:13.083] }
[21:39:13.083] else {
[21:39:13.083] ...future.result["stdout"] <- base::list(NULL)
[21:39:13.083] }
[21:39:13.083] base::close(...future.stdout)
[21:39:13.083] ...future.stdout <- NULL
[21:39:13.083] }
[21:39:13.083] ...future.result$conditions <- ...future.conditions
[21:39:13.083] ...future.result$finished <- base::Sys.time()
[21:39:13.083] ...future.result
[21:39:13.083] }
[21:39:13.107] assign_globals() ...
[21:39:13.108] List of 5
[21:39:13.108] $ ...future.FUN :function (x, y)
[21:39:13.108] $ MoreArgs : NULL
[21:39:13.108] $ ...future.elements_ii :List of 2
[21:39:13.108] ..$ :List of 2
[21:39:13.108] .. ..$ : int 1
[21:39:13.108] .. ..$ : int 0
[21:39:13.108] ..$ :List of 2
[21:39:13.108] .. ..$ : int 0
[21:39:13.108] .. ..$ : int 1
[21:39:13.108] $ ...future.seeds_ii : NULL
[21:39:13.108] $ ...future.globals.maxSize: NULL
[21:39:13.108] - attr(*, "resolved")= logi FALSE
[21:39:13.108] - attr(*, "total_size")= num 6480
[21:39:13.108] - attr(*, "where")=List of 5
[21:39:13.108] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:13.108] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:13.108] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:13.108] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:13.108] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:13.108] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:13.108] - attr(*, "already-done")= logi TRUE
[21:39:13.137] - reassign environment for '...future.FUN'
[21:39:13.137] - copied '...future.FUN' to environment
[21:39:13.138] - copied 'MoreArgs' to environment
[21:39:13.138] - copied '...future.elements_ii' to environment
[21:39:13.138] - copied '...future.seeds_ii' to environment
[21:39:13.138] - copied '...future.globals.maxSize' to environment
[21:39:13.139] assign_globals() ... done
[21:39:13.139] plan(): Setting new future strategy stack:
[21:39:13.140] List of future strategies:
[21:39:13.140] 1. sequential:
[21:39:13.140] - args: function (..., envir = parent.frame())
[21:39:13.140] - tweaked: FALSE
[21:39:13.140] - call: NULL
[21:39:13.140] plan(): nbrOfWorkers() = 1
[21:39:13.643] plan(): Setting new future strategy stack:
[21:39:13.643] List of future strategies:
[21:39:13.643] 1. multisession:
[21:39:13.643] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[21:39:13.643] - tweaked: FALSE
[21:39:13.643] - call: plan(strategy)
[21:39:13.677] plan(): nbrOfWorkers() = 1
[21:39:13.678] SequentialFuture started (and completed)
[21:39:13.678] - Launch lazy future ... done
[21:39:13.678] run() for 'SequentialFuture' ... done
[21:39:13.678] Created future:
[21:39:13.679] SequentialFuture:
[21:39:13.679] Label: 'future_mapply-1'
[21:39:13.679] Expression:
[21:39:13.679] {
[21:39:13.679] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:13.679] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:13.679] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:13.679] on.exit(options(oopts), add = TRUE)
[21:39:13.679] }
[21:39:13.679] {
[21:39:13.679] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:13.679] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[21:39:13.679] do.call(mapply, args = args)
[21:39:13.679] }
[21:39:13.679] }
[21:39:13.679] Lazy evaluation: FALSE
[21:39:13.679] Asynchronous evaluation: FALSE
[21:39:13.679] Local evaluation: TRUE
[21:39:13.679] Environment: R_GlobalEnv
[21:39:13.679] Capture standard output: TRUE
[21:39:13.679] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:13.679] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:13.679] Packages: <none>
[21:39:13.679] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:13.679] Resolved: TRUE
[21:39:13.679] Value: 224 bytes of class 'list'
[21:39:13.679] Early signaling: FALSE
[21:39:13.679] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:13.679] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:13.681] Chunk #1 of 1 ... DONE
[21:39:13.681] Launching 1 futures (chunks) ... DONE
[21:39:13.681] Resolving 1 futures (chunks) ...
[21:39:13.681] resolve() on list ...
[21:39:13.681] recursive: 0
[21:39:13.682] length: 1
[21:39:13.682]
[21:39:13.682] resolved() for 'SequentialFuture' ...
[21:39:13.682] - state: 'finished'
[21:39:13.683] - run: TRUE
[21:39:13.683] - result: 'FutureResult'
[21:39:13.683] resolved() for 'SequentialFuture' ... done
[21:39:13.683] Future #1
[21:39:13.684] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:13.684] - nx: 1
[21:39:13.684] - relay: TRUE
[21:39:13.684] - stdout: TRUE
[21:39:13.684] - signal: TRUE
[21:39:13.684] - resignal: FALSE
[21:39:13.685] - force: TRUE
[21:39:13.685] - relayed: [n=1] FALSE
[21:39:13.685] - queued futures: [n=1] FALSE
[21:39:13.685] - until=1
[21:39:13.685] - relaying element #1
[21:39:13.686] - relayed: [n=1] TRUE
[21:39:13.686] - queued futures: [n=1] TRUE
[21:39:13.686] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:13.687] length: 0 (resolved future 1)
[21:39:13.687] Relaying remaining futures
[21:39:13.687] signalConditionsASAP(NULL, pos=0) ...
[21:39:13.687] - nx: 1
[21:39:13.687] - relay: TRUE
[21:39:13.688] - stdout: TRUE
[21:39:13.688] - signal: TRUE
[21:39:13.688] - resignal: FALSE
[21:39:13.688] - force: TRUE
[21:39:13.688] - relayed: [n=1] TRUE
[21:39:13.689] - queued futures: [n=1] TRUE
- flush all
[21:39:13.689] - relayed: [n=1] TRUE
[21:39:13.689] - queued futures: [n=1] TRUE
[21:39:13.689] signalConditionsASAP(NULL, pos=0) ... done
[21:39:13.690] resolve() on list ... DONE
[21:39:13.690] - Number of value chunks collected: 1
[21:39:13.690] Resolving 1 futures (chunks) ... DONE
[21:39:13.690] Reducing values from 1 chunks ...
[21:39:13.703] - Number of values collected after concatenation: 2
[21:39:13.703] - Number of values expected: 2
[21:39:13.703] Reducing values from 1 chunks ... DONE
[21:39:13.704] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = TRUE) ... DONE
* future_mapply(x, ..., future.stdout = NA) ...
[21:39:13.705] future_mapply() ...
[21:39:13.738] Number of chunks: 1
[21:39:13.738] getGlobalsAndPackagesXApply() ...
[21:39:13.738] - future.globals: TRUE
[21:39:13.739] getGlobalsAndPackages() ...
[21:39:13.739] Searching for globals...
[21:39:13.742] - globals found: [6] 'FUN', '{', 'Sys.sleep', '/', 'print', 'list'
[21:39:13.743] Searching for globals ... DONE
[21:39:13.743] Resolving globals: FALSE
[21:39:13.744] The total size of the 1 globals is 6.11 KiB (6256 bytes)
[21:39:13.744] The total size of the 1 globals exported for future expression ('FUN()') is 6.11 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (6.11 KiB of class 'function')
[21:39:13.745] - globals: [1] 'FUN'
[21:39:13.745]
[21:39:13.745] getGlobalsAndPackages() ... DONE
[21:39:13.745] - globals found/used: [n=1] 'FUN'
[21:39:13.746] - needed namespaces: [n=0]
[21:39:13.746] Finding globals ... DONE
[21:39:13.746] Globals to be used in all futures (chunks): [n=2] '...future.FUN', 'MoreArgs'
[21:39:13.746] List of 2
[21:39:13.746] $ ...future.FUN:function (x, y)
[21:39:13.746] $ MoreArgs : NULL
[21:39:13.746] - attr(*, "where")=List of 2
[21:39:13.746] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:13.746] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:13.746] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:13.746] - attr(*, "resolved")= logi FALSE
[21:39:13.746] - attr(*, "total_size")= num NA
[21:39:13.765] Packages to be attached in all futures: [n=0]
[21:39:13.765] getGlobalsAndPackagesXApply() ... DONE
[21:39:13.766] Number of futures (= number of chunks): 1
[21:39:13.766] Launching 1 futures (chunks) ...
[21:39:13.766] Chunk #1 of 1 ...
[21:39:13.766] - Finding globals in '...' for chunk #1 ...
[21:39:13.767] getGlobalsAndPackages() ...
[21:39:13.767] Searching for globals...
[21:39:13.767]
[21:39:13.768] Searching for globals ... DONE
[21:39:13.768] - globals: [0] <none>
[21:39:13.768] getGlobalsAndPackages() ... DONE
[21:39:13.768] + additional globals found: [n=0]
[21:39:13.769] + additional namespaces needed: [n=0]
[21:39:13.769] - Finding globals in '...' for chunk #1 ... DONE
[21:39:13.769] - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[21:39:13.769] - seeds: <none>
[21:39:13.769] getGlobalsAndPackages() ...
[21:39:13.770] - globals passed as-is: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:13.770] Resolving globals: FALSE
[21:39:13.771] The total size of the 5 globals is 6.33 KiB (6480 bytes)
[21:39:13.772] The total size of the 5 globals exported for future expression ('{; ...future.globals.maxSize.org <- getOption("future.globals.maxSize"); if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {; oopts <- options(future.globals.maxSize = ...future.globals.maxSize); on.exit(options(oopts), add = TRUE); }; ...; do.call(mapply, args = args); }; }') is 6.33 KiB.. This exceeds the maximum allowed size of 0.98 GiB (option 'future.globals.maxSize'). The three largest globals are '...future.FUN' (6.11 KiB of class 'function'), '...future.elements_ii' (224 bytes of class 'list') and 'MoreArgs' (0 bytes of class 'NULL')
[21:39:13.772] - globals: [5] '...future.FUN', 'MoreArgs', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:13.772]
[21:39:13.773] getGlobalsAndPackages() ... DONE
[21:39:13.773] run() for 'Future' ...
[21:39:13.773] - state: 'created'
[21:39:13.774] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[21:39:13.815] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:13.815] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[21:39:13.815] - Field: 'label'
[21:39:13.816] - Field: 'local'
[21:39:13.816] - Field: 'owner'
[21:39:13.816] - Field: 'envir'
[21:39:13.817] - Field: 'packages'
[21:39:13.817] - Field: 'gc'
[21:39:13.817] - Field: 'conditions'
[21:39:13.817] - Field: 'expr'
[21:39:13.818] - Field: 'uuid'
[21:39:13.818] - Field: 'seed'
[21:39:13.818] - Field: 'version'
[21:39:13.819] - Field: 'result'
[21:39:13.819] - Field: 'asynchronous'
[21:39:13.819] - Field: 'calls'
[21:39:13.819] - Field: 'globals'
[21:39:13.820] - Field: 'stdout'
[21:39:13.820] - Field: 'earlySignal'
[21:39:13.820] - Field: 'lazy'
[21:39:13.820] - Field: 'state'
[21:39:13.821] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[21:39:13.821] - Launch lazy future ...
[21:39:13.821] Packages needed by the future expression (n = 0): <none>
[21:39:13.822] Packages needed by future strategies (n = 0): <none>
[21:39:13.823] {
[21:39:13.823] {
[21:39:13.823] {
[21:39:13.823] ...future.startTime <- base::Sys.time()
[21:39:13.823] {
[21:39:13.823] {
[21:39:13.823] {
[21:39:13.823] base::local({
[21:39:13.823] has_future <- base::requireNamespace("future",
[21:39:13.823] quietly = TRUE)
[21:39:13.823] if (has_future) {
[21:39:13.823] ns <- base::getNamespace("future")
[21:39:13.823] version <- ns[[".package"]][["version"]]
[21:39:13.823] if (is.null(version))
[21:39:13.823] version <- utils::packageVersion("future")
[21:39:13.823] }
[21:39:13.823] else {
[21:39:13.823] version <- NULL
[21:39:13.823] }
[21:39:13.823] if (!has_future || version < "1.8.0") {
[21:39:13.823] info <- base::c(r_version = base::gsub("R version ",
[21:39:13.823] "", base::R.version$version.string),
[21:39:13.823] platform = base::sprintf("%s (%s-bit)",
[21:39:13.823] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:13.823] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:13.823] "release", "version")], collapse = " "),
[21:39:13.823] hostname = base::Sys.info()[["nodename"]])
[21:39:13.823] info <- base::sprintf("%s: %s", base::names(info),
[21:39:13.823] info)
[21:39:13.823] info <- base::paste(info, collapse = "; ")
[21:39:13.823] if (!has_future) {
[21:39:13.823] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:13.823] info)
[21:39:13.823] }
[21:39:13.823] else {
[21:39:13.823] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:13.823] info, version)
[21:39:13.823] }
[21:39:13.823] base::stop(msg)
[21:39:13.823] }
[21:39:13.823] })
[21:39:13.823] }
[21:39:13.823] options(future.plan = NULL)
[21:39:13.823] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:13.823] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:13.823] }
[21:39:13.823] ...future.workdir <- getwd()
[21:39:13.823] }
[21:39:13.823] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:13.823] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:13.823] }
[21:39:13.823] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:13.823] future.globals.maxSize = 1048576000, future.globals.method = NULL,
[21:39:13.823] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:13.823] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:13.823] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:13.823] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:13.823] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:13.823] base::names(...future.oldOptions))
[21:39:13.823] }
[21:39:13.823] if (TRUE) {
[21:39:13.823] }
[21:39:13.823] else {
[21:39:13.823] if (NA) {
[21:39:13.823] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:13.823] open = "w")
[21:39:13.823] }
[21:39:13.823] else {
[21:39:13.823] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:13.823] windows = "NUL", "/dev/null"), open = "w")
[21:39:13.823] }
[21:39:13.823] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:13.823] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:13.823] base::sink(type = "output", split = FALSE)
[21:39:13.823] base::close(...future.stdout)
[21:39:13.823] }, add = TRUE)
[21:39:13.823] }
[21:39:13.823] ...future.frame <- base::sys.nframe()
[21:39:13.823] ...future.conditions <- base::list()
[21:39:13.823] ...future.rng <- base::globalenv()$.Random.seed
[21:39:13.823] if (FALSE) {
[21:39:13.823] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:13.823] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:13.823] }
[21:39:13.823] ...future.result <- base::tryCatch({
[21:39:13.823] base::withCallingHandlers({
[21:39:13.823] ...future.value <- base::withVisible(base::local({
[21:39:13.823] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:13.823] if (!identical(...future.globals.maxSize.org,
[21:39:13.823] ...future.globals.maxSize)) {
[21:39:13.823] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:13.823] on.exit(options(oopts), add = TRUE)
[21:39:13.823] }
[21:39:13.823] {
[21:39:13.823] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:13.823] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE,
[21:39:13.823] USE.NAMES = FALSE)
[21:39:13.823] do.call(mapply, args = args)
[21:39:13.823] }
[21:39:13.823] }))
[21:39:13.823] future::FutureResult(value = ...future.value$value,
[21:39:13.823] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:13.823] ...future.rng), globalenv = if (FALSE)
[21:39:13.823] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:13.823] ...future.globalenv.names))
[21:39:13.823] else NULL, started = ...future.startTime, version = "1.8")
[21:39:13.823] }, condition = base::local({
[21:39:13.823] c <- base::c
[21:39:13.823] inherits <- base::inherits
[21:39:13.823] invokeRestart <- base::invokeRestart
[21:39:13.823] length <- base::length
[21:39:13.823] list <- base::list
[21:39:13.823] seq.int <- base::seq.int
[21:39:13.823] signalCondition <- base::signalCondition
[21:39:13.823] sys.calls <- base::sys.calls
[21:39:13.823] `[[` <- base::`[[`
[21:39:13.823] `+` <- base::`+`
[21:39:13.823] `<<-` <- base::`<<-`
[21:39:13.823] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:13.823] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:13.823] 3L)]
[21:39:13.823] }
[21:39:13.823] function(cond) {
[21:39:13.823] is_error <- inherits(cond, "error")
[21:39:13.823] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:13.823] NULL)
[21:39:13.823] if (is_error) {
[21:39:13.823] sessionInformation <- function() {
[21:39:13.823] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:13.823] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:13.823] search = base::search(), system = base::Sys.info())
[21:39:13.823] }
[21:39:13.823] ...future.conditions[[length(...future.conditions) +
[21:39:13.823] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:13.823] cond$call), session = sessionInformation(),
[21:39:13.823] timestamp = base::Sys.time(), signaled = 0L)
[21:39:13.823] signalCondition(cond)
[21:39:13.823] }
[21:39:13.823] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:13.823] "immediateCondition"))) {
[21:39:13.823] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:13.823] ...future.conditions[[length(...future.conditions) +
[21:39:13.823] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:13.823] if (TRUE && !signal) {
[21:39:13.823] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:13.823] {
[21:39:13.823] inherits <- base::inherits
[21:39:13.823] invokeRestart <- base::invokeRestart
[21:39:13.823] is.null <- base::is.null
[21:39:13.823] muffled <- FALSE
[21:39:13.823] if (inherits(cond, "message")) {
[21:39:13.823] muffled <- grepl(pattern, "muffleMessage")
[21:39:13.823] if (muffled)
[21:39:13.823] invokeRestart("muffleMessage")
[21:39:13.823] }
[21:39:13.823] else if (inherits(cond, "warning")) {
[21:39:13.823] muffled <- grepl(pattern, "muffleWarning")
[21:39:13.823] if (muffled)
[21:39:13.823] invokeRestart("muffleWarning")
[21:39:13.823] }
[21:39:13.823] else if (inherits(cond, "condition")) {
[21:39:13.823] if (!is.null(pattern)) {
[21:39:13.823] computeRestarts <- base::computeRestarts
[21:39:13.823] grepl <- base::grepl
[21:39:13.823] restarts <- computeRestarts(cond)
[21:39:13.823] for (restart in restarts) {
[21:39:13.823] name <- restart$name
[21:39:13.823] if (is.null(name))
[21:39:13.823] next
[21:39:13.823] if (!grepl(pattern, name))
[21:39:13.823] next
[21:39:13.823] invokeRestart(restart)
[21:39:13.823] muffled <- TRUE
[21:39:13.823] break
[21:39:13.823] }
[21:39:13.823] }
[21:39:13.823] }
[21:39:13.823] invisible(muffled)
[21:39:13.823] }
[21:39:13.823] muffleCondition(cond, pattern = "^muffle")
[21:39:13.823] }
[21:39:13.823] }
[21:39:13.823] else {
[21:39:13.823] if (TRUE) {
[21:39:13.823] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:13.823] {
[21:39:13.823] inherits <- base::inherits
[21:39:13.823] invokeRestart <- base::invokeRestart
[21:39:13.823] is.null <- base::is.null
[21:39:13.823] muffled <- FALSE
[21:39:13.823] if (inherits(cond, "message")) {
[21:39:13.823] muffled <- grepl(pattern, "muffleMessage")
[21:39:13.823] if (muffled)
[21:39:13.823] invokeRestart("muffleMessage")
[21:39:13.823] }
[21:39:13.823] else if (inherits(cond, "warning")) {
[21:39:13.823] muffled <- grepl(pattern, "muffleWarning")
[21:39:13.823] if (muffled)
[21:39:13.823] invokeRestart("muffleWarning")
[21:39:13.823] }
[21:39:13.823] else if (inherits(cond, "condition")) {
[21:39:13.823] if (!is.null(pattern)) {
[21:39:13.823] computeRestarts <- base::computeRestarts
[21:39:13.823] grepl <- base::grepl
[21:39:13.823] restarts <- computeRestarts(cond)
[21:39:13.823] for (restart in restarts) {
[21:39:13.823] name <- restart$name
[21:39:13.823] if (is.null(name))
[21:39:13.823] next
[21:39:13.823] if (!grepl(pattern, name))
[21:39:13.823] next
[21:39:13.823] invokeRestart(restart)
[21:39:13.823] muffled <- TRUE
[21:39:13.823] break
[21:39:13.823] }
[21:39:13.823] }
[21:39:13.823] }
[21:39:13.823] invisible(muffled)
[21:39:13.823] }
[21:39:13.823] muffleCondition(cond, pattern = "^muffle")
[21:39:13.823] }
[21:39:13.823] }
[21:39:13.823] }
[21:39:13.823] }))
[21:39:13.823] }, error = function(ex) {
[21:39:13.823] base::structure(base::list(value = NULL, visible = NULL,
[21:39:13.823] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:13.823] ...future.rng), started = ...future.startTime,
[21:39:13.823] finished = Sys.time(), session_uuid = NA_character_,
[21:39:13.823] version = "1.8"), class = "FutureResult")
[21:39:13.823] }, finally = {
[21:39:13.823] if (!identical(...future.workdir, getwd()))
[21:39:13.823] setwd(...future.workdir)
[21:39:13.823] {
[21:39:13.823] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:13.823] ...future.oldOptions$nwarnings <- NULL
[21:39:13.823] }
[21:39:13.823] base::options(...future.oldOptions)
[21:39:13.823] if (.Platform$OS.type == "windows") {
[21:39:13.823] old_names <- names(...future.oldEnvVars)
[21:39:13.823] envs <- base::Sys.getenv()
[21:39:13.823] names <- names(envs)
[21:39:13.823] common <- intersect(names, old_names)
[21:39:13.823] added <- setdiff(names, old_names)
[21:39:13.823] removed <- setdiff(old_names, names)
[21:39:13.823] changed <- common[...future.oldEnvVars[common] !=
[21:39:13.823] envs[common]]
[21:39:13.823] NAMES <- toupper(changed)
[21:39:13.823] args <- list()
[21:39:13.823] for (kk in seq_along(NAMES)) {
[21:39:13.823] name <- changed[[kk]]
[21:39:13.823] NAME <- NAMES[[kk]]
[21:39:13.823] if (name != NAME && is.element(NAME, old_names))
[21:39:13.823] next
[21:39:13.823] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:13.823] }
[21:39:13.823] NAMES <- toupper(added)
[21:39:13.823] for (kk in seq_along(NAMES)) {
[21:39:13.823] name <- added[[kk]]
[21:39:13.823] NAME <- NAMES[[kk]]
[21:39:13.823] if (name != NAME && is.element(NAME, old_names))
[21:39:13.823] next
[21:39:13.823] args[[name]] <- ""
[21:39:13.823] }
[21:39:13.823] NAMES <- toupper(removed)
[21:39:13.823] for (kk in seq_along(NAMES)) {
[21:39:13.823] name <- removed[[kk]]
[21:39:13.823] NAME <- NAMES[[kk]]
[21:39:13.823] if (name != NAME && is.element(NAME, old_names))
[21:39:13.823] next
[21:39:13.823] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:13.823] }
[21:39:13.823] if (length(args) > 0)
[21:39:13.823] base::do.call(base::Sys.setenv, args = args)
[21:39:13.823] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:13.823] }
[21:39:13.823] else {
[21:39:13.823] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:13.823] }
[21:39:13.823] {
[21:39:13.823] if (base::length(...future.futureOptionsAdded) >
[21:39:13.823] 0L) {
[21:39:13.823] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:13.823] base::names(opts) <- ...future.futureOptionsAdded
[21:39:13.823] base::options(opts)
[21:39:13.823] }
[21:39:13.823] {
[21:39:13.823] {
[21:39:13.823] NULL
[21:39:13.823] RNGkind("Mersenne-Twister")
[21:39:13.823] base::rm(list = ".Random.seed", envir = base::globalenv(),
[21:39:13.823] inherits = FALSE)
[21:39:13.823] }
[21:39:13.823] options(future.plan = NULL)
[21:39:13.823] if (is.na(NA_character_))
[21:39:13.823] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:13.823] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:13.823] future::plan(list(function (..., workers = availableCores(),
[21:39:13.823] lazy = FALSE, rscript_libs = .libPaths(),
[21:39:13.823] envir = parent.frame())
[21:39:13.823] {
[21:39:13.823] if (is.function(workers))
[21:39:13.823] workers <- workers()
[21:39:13.823] workers <- structure(as.integer(workers),
[21:39:13.823] class = class(workers))
[21:39:13.823] stop_if_not(length(workers) == 1, is.finite(workers),
[21:39:13.823] workers >= 1)
[21:39:13.823] if (workers == 1L && !inherits(workers, "AsIs")) {
[21:39:13.823] return(sequential(..., lazy = TRUE, envir = envir))
[21:39:13.823] }
[21:39:13.823] future <- MultisessionFuture(..., workers = workers,
[21:39:13.823] lazy = lazy, rscript_libs = rscript_libs,
[21:39:13.823] envir = envir)
[21:39:13.823] if (!future$lazy)
[21:39:13.823] future <- run(future)
[21:39:13.823] invisible(future)
[21:39:13.823] }), .cleanup = FALSE, .init = FALSE)
[21:39:13.823] }
[21:39:13.823] }
[21:39:13.823] }
[21:39:13.823] })
[21:39:13.823] if (FALSE) {
[21:39:13.823] base::sink(type = "output", split = FALSE)
[21:39:13.823] if (NA) {
[21:39:13.823] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:13.823] }
[21:39:13.823] else {
[21:39:13.823] ...future.result["stdout"] <- base::list(NULL)
[21:39:13.823] }
[21:39:13.823] base::close(...future.stdout)
[21:39:13.823] ...future.stdout <- NULL
[21:39:13.823] }
[21:39:13.823] ...future.result$conditions <- ...future.conditions
[21:39:13.823] ...future.result$finished <- base::Sys.time()
[21:39:13.823] ...future.result
[21:39:13.823] }
[21:39:13.839] assign_globals() ...
[21:39:13.839] List of 5
[21:39:13.839] $ ...future.FUN :function (x, y)
[21:39:13.839] $ MoreArgs : NULL
[21:39:13.839] $ ...future.elements_ii :List of 2
[21:39:13.839] ..$ :List of 2
[21:39:13.839] .. ..$ : int 1
[21:39:13.839] .. ..$ : int 0
[21:39:13.839] ..$ :List of 2
[21:39:13.839] .. ..$ : int 0
[21:39:13.839] .. ..$ : int 1
[21:39:13.839] $ ...future.seeds_ii : NULL
[21:39:13.839] $ ...future.globals.maxSize: NULL
[21:39:13.839] - attr(*, "resolved")= logi FALSE
[21:39:13.839] - attr(*, "total_size")= num 6480
[21:39:13.839] - attr(*, "where")=List of 5
[21:39:13.839] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:13.839] ..$ MoreArgs :<environment: R_EmptyEnv>
[21:39:13.839] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:13.839] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:13.839] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:13.839] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:13.839] - attr(*, "already-done")= logi TRUE
[21:39:13.862] - reassign environment for '...future.FUN'
[21:39:13.862] - copied '...future.FUN' to environment
[21:39:13.862] - copied 'MoreArgs' to environment
[21:39:13.863] - copied '...future.elements_ii' to environment
[21:39:13.863] - copied '...future.seeds_ii' to environment
[21:39:13.863] - copied '...future.globals.maxSize' to environment
[21:39:13.863] assign_globals() ... done
[21:39:13.864] plan(): Setting new future strategy stack:
[21:39:13.864] List of future strategies:
[21:39:13.864] 1. sequential:
[21:39:13.864] - args: function (..., envir = parent.frame())
[21:39:13.864] - tweaked: FALSE
[21:39:13.864] - call: NULL
[21:39:13.865] plan(): nbrOfWorkers() = 1
[21:39:14.367] plan(): Setting new future strategy stack:
[21:39:14.368] List of future strategies:
[21:39:14.368] 1. multisession:
[21:39:14.368] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[21:39:14.368] - tweaked: FALSE
[21:39:14.368] - call: plan(strategy)
[21:39:14.394] plan(): nbrOfWorkers() = 1
[21:39:14.394] SequentialFuture started (and completed)
[21:39:14.395] - Launch lazy future ... done
[21:39:14.395] run() for 'SequentialFuture' ... done
[21:39:14.395] Created future:
[21:39:14.395] SequentialFuture:
[21:39:14.395] Label: 'future_mapply-1'
[21:39:14.395] Expression:
[21:39:14.395] {
[21:39:14.395] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:14.395] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:14.395] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:14.395] on.exit(options(oopts), add = TRUE)
[21:39:14.395] }
[21:39:14.395] {
[21:39:14.395] args <- c(list(FUN = ...future.FUN), ...future.elements_ii,
[21:39:14.395] MoreArgs = list(MoreArgs), SIMPLIFY = FALSE, USE.NAMES = FALSE)
[21:39:14.395] do.call(mapply, args = args)
[21:39:14.395] }
[21:39:14.395] }
[21:39:14.395] Lazy evaluation: FALSE
[21:39:14.395] Asynchronous evaluation: FALSE
[21:39:14.395] Local evaluation: TRUE
[21:39:14.395] Environment: R_GlobalEnv
[21:39:14.395] Capture standard output: NA
[21:39:14.395] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:14.395] Globals: 5 objects totaling 6.33 KiB (function '...future.FUN' of 6.11 KiB, NULL 'MoreArgs' of 0 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:14.395] Packages: <none>
[21:39:14.395] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:14.395] Resolved: TRUE
[21:39:14.395] Value: 224 bytes of class 'list'
[21:39:14.395] Early signaling: FALSE
[21:39:14.395] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:14.395] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[21:39:14.397] Chunk #1 of 1 ... DONE
[21:39:14.398] Launching 1 futures (chunks) ... DONE
[21:39:14.398] Resolving 1 futures (chunks) ...
[21:39:14.398] resolve() on list ...
[21:39:14.398] recursive: 0
[21:39:14.398] length: 1
[21:39:14.399]
[21:39:14.399] resolved() for 'SequentialFuture' ...
[21:39:14.399] - state: 'finished'
[21:39:14.399] - run: TRUE
[21:39:14.400] - result: 'FutureResult'
[21:39:14.400] resolved() for 'SequentialFuture' ... done
[21:39:14.400] Future #1
[21:39:14.400] signalConditionsASAP(SequentialFuture, pos=1) ...
[21:39:14.401] - nx: 1
[21:39:14.401] - relay: TRUE
[21:39:14.401] - stdout: TRUE
[21:39:14.401] - signal: TRUE
[21:39:14.401] - resignal: FALSE
[21:39:14.401] - force: TRUE
[21:39:14.402] - relayed: [n=1] FALSE
[21:39:14.402] - queued futures: [n=1] FALSE
[21:39:14.402] - until=1
[21:39:14.402] - relaying element #1
[21:39:14.403] - relayed: [n=1] TRUE
[21:39:14.403] - queued futures: [n=1] TRUE
[21:39:14.403] signalConditionsASAP(SequentialFuture, pos=1) ... done
[21:39:14.403] length: 0 (resolved future 1)
[21:39:14.404] Relaying remaining futures
[21:39:14.404] signalConditionsASAP(NULL, pos=0) ...
[21:39:14.404] - nx: 1
[21:39:14.404] - relay: TRUE
[21:39:14.404] - stdout: TRUE
[21:39:14.405] - signal: TRUE
[21:39:14.405] - resignal: FALSE
[21:39:14.405] - force: TRUE
[21:39:14.405] - relayed: [n=1] TRUE
[21:39:14.405] - queued futures: [n=1] TRUE
- flush all
[21:39:14.406] - relayed: [n=1] TRUE
[21:39:14.406] - queued futures: [n=1] TRUE
[21:39:14.406] signalConditionsASAP(NULL, pos=0) ... done
[21:39:14.406] resolve() on list ... DONE
[21:39:14.407] - Number of value chunks collected: 1
[21:39:14.407] Resolving 1 futures (chunks) ... DONE
[21:39:14.407] Reducing values from 1 chunks ...
[21:39:14.407] - Number of values collected after concatenation: 2
[21:39:14.407] - Number of values expected: 2
[21:39:14.408] Reducing values from 1 chunks ... DONE
[21:39:14.408] future_mapply() ... DONE
* future_mapply(x, ..., future.stdout = NA) ... DONE
* plan('multisession') ... DONE
- Testing with 1 cores ... DONE
- Testing with 2 cores ...
* plan('multicore') ...
[21:39:14.432] plan(): Setting new future strategy stack:
[21:39:14.433] List of future strategies:
[21:39:14.433] 1. multicore:
[21:39:14.433] - args: function (..., workers = availableCores(constraints = "multicore"), envir = parent.frame())
[21:39:14.433] - tweaked: FALSE
[21:39:14.433] - call: plan(strategy)
[21:39:14.461] plan(): nbrOfWorkers() = 2
* future_lapply(x, ..., future.stdout = FALSE) ...
[21:39:14.462] future_lapply() ...
[21:39:14.493] Number of chunks: 2
[21:39:14.494] getGlobalsAndPackagesXApply() ...
[21:39:14.494] - future.globals: TRUE
[21:39:14.494] getGlobalsAndPackages() ...
[21:39:14.494] Searching for globals...
[21:39:14.498] - globals found: [5] 'FUN', '{', 'Sys.sleep', '/', 'print'
[21:39:14.498] Searching for globals ... DONE
[21:39:14.498] Resolving globals: FALSE
[21:39:14.499] The total size of the 1 globals is 4.61 KiB (4720 bytes)
[21:39:14.500] The total size of the 1 globals exported for future expression ('FUN()') is 4.61 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (4.61 KiB of class 'function')
[21:39:14.500] - globals: [1] 'FUN'
[21:39:14.500]
[21:39:14.501] getGlobalsAndPackages() ... DONE
[21:39:14.501] - globals found/used: [n=1] 'FUN'
[21:39:14.501] - needed namespaces: [n=0]
[21:39:14.501] Finding globals ... DONE
[21:39:14.502] - use_args: TRUE
[21:39:14.502] - Getting '...' globals ...
[21:39:14.519] resolve() on list ...
[21:39:14.519] recursive: 0
[21:39:14.519] length: 1
[21:39:14.519] elements: '...'
[21:39:14.520] length: 0 (resolved future 1)
[21:39:14.520] resolve() on list ... DONE
[21:39:14.520] - '...' content: [n=0]
[21:39:14.520] List of 1
[21:39:14.520] $ ...: list()
[21:39:14.520] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:14.520] - attr(*, "where")=List of 1
[21:39:14.520] ..$ ...:<environment: 0x55c1ee29fd28>
[21:39:14.520] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:14.520] - attr(*, "resolved")= logi TRUE
[21:39:14.520] - attr(*, "total_size")= num NA
[21:39:14.527] - Getting '...' globals ... DONE
[21:39:14.527] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[21:39:14.527] List of 2
[21:39:14.527] $ ...future.FUN:function (x)
[21:39:14.527] $ ... : list()
[21:39:14.527] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:14.527] - attr(*, "where")=List of 2
[21:39:14.527] ..$ ...future.FUN:<environment: R_EmptyEnv>
[21:39:14.527] ..$ ... :<environment: 0x55c1ee29fd28>
[21:39:14.527] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:14.527] - attr(*, "resolved")= logi FALSE
[21:39:14.527] - attr(*, "total_size")= num 4720
[21:39:14.534] Packages to be attached in all futures: [n=0]
[21:39:14.534] getGlobalsAndPackagesXApply() ... DONE
[21:39:14.551] Number of futures (= number of chunks): 2
[21:39:14.551] Launching 2 futures (chunks) ...
[21:39:14.551] Chunk #1 of 2 ...
[21:39:14.552] - Finding globals in 'X' for chunk #1 ...
[21:39:14.552] getGlobalsAndPackages() ...
[21:39:14.552] Searching for globals...
[21:39:14.553]
[21:39:14.553] Searching for globals ... DONE
[21:39:14.553] - globals: [0] <none>
[21:39:14.553] getGlobalsAndPackages() ... DONE
[21:39:14.554] + additional globals found: [n=0]
[21:39:14.554] + additional namespaces needed: [n=0]
[21:39:14.554] - Finding globals in 'X' for chunk #1 ... DONE
[21:39:14.554] - seeds: <none>
[21:39:14.555] getGlobalsAndPackages() ...
[21:39:14.555] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:14.555] Resolving globals: FALSE
[21:39:14.555] Tweak future expression to call with '...' arguments ...
[21:39:14.556] {
[21:39:14.556] do.call(function(...) {
[21:39:14.556] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:14.556] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:14.556] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:14.556] on.exit(options(oopts), add = TRUE)
[21:39:14.556] }
[21:39:14.556] {
[21:39:14.556] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:14.556] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:14.556] ...future.FUN(...future.X_jj, ...)
[21:39:14.556] })
[21:39:14.556] }
[21:39:14.556] }, args = future.call.arguments)
[21:39:14.556] }
[21:39:14.556] Tweak future expression to call with '...' arguments ... DONE
[21:39:14.557] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:14.558]
[21:39:14.558] getGlobalsAndPackages() ... DONE
[21:39:14.558] run() for 'Future' ...
[21:39:14.559] - state: 'created'
[21:39:14.563] - Future backend: 'FutureStrategy', 'multicore', 'multiprocess', 'future', 'function'
[21:39:14.602] - Future class: 'MulticoreFuture', 'MultiprocessFuture', 'Future', 'environment'
[21:39:14.602] - Copy elements of temporary 'MulticoreFuture' to final 'Future' object ...
[21:39:14.603] - Field: 'label'
[21:39:14.603] - Field: 'local'
[21:39:14.603] - Field: 'owner'
[21:39:14.603] - Field: 'envir'
[21:39:14.604] - Field: 'workers'
[21:39:14.604] - Field: 'packages'
[21:39:14.604] - Field: 'gc'
[21:39:14.604] - Field: 'job'
[21:39:14.605] - Field: 'conditions'
[21:39:14.605] - Field: 'expr'
[21:39:14.605] - Field: 'uuid'
[21:39:14.605] - Field: 'seed'
[21:39:14.605] - Field: 'version'
[21:39:14.606] - Field: 'result'
[21:39:14.606] - Field: 'asynchronous'
[21:39:14.606] - Field: 'calls'
[21:39:14.606] - Field: 'globals'
[21:39:14.607] - Field: 'stdout'
[21:39:14.607] - Field: 'earlySignal'
[21:39:14.607] - Field: 'lazy'
[21:39:14.607] - Field: 'state'
[21:39:14.607] - Copy elements of temporary 'MulticoreFuture' to final 'Future' object ... done
[21:39:14.608] - Launch lazy future ...
[21:39:14.610] Packages needed by the future expression (n = 0): <none>
[21:39:14.610] Packages needed by future strategies (n = 0): <none>
[21:39:14.611] {
[21:39:14.611] {
[21:39:14.611] {
[21:39:14.611] ...future.startTime <- base::Sys.time()
[21:39:14.611] {
[21:39:14.611] {
[21:39:14.611] {
[21:39:14.611] {
[21:39:14.611] base::local({
[21:39:14.611] has_future <- base::requireNamespace("future",
[21:39:14.611] quietly = TRUE)
[21:39:14.611] if (has_future) {
[21:39:14.611] ns <- base::getNamespace("future")
[21:39:14.611] version <- ns[[".package"]][["version"]]
[21:39:14.611] if (is.null(version))
[21:39:14.611] version <- utils::packageVersion("future")
[21:39:14.611] }
[21:39:14.611] else {
[21:39:14.611] version <- NULL
[21:39:14.611] }
[21:39:14.611] if (!has_future || version < "1.8.0") {
[21:39:14.611] info <- base::c(r_version = base::gsub("R version ",
[21:39:14.611] "", base::R.version$version.string),
[21:39:14.611] platform = base::sprintf("%s (%s-bit)",
[21:39:14.611] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:14.611] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:14.611] "release", "version")], collapse = " "),
[21:39:14.611] hostname = base::Sys.info()[["nodename"]])
[21:39:14.611] info <- base::sprintf("%s: %s", base::names(info),
[21:39:14.611] info)
[21:39:14.611] info <- base::paste(info, collapse = "; ")
[21:39:14.611] if (!has_future) {
[21:39:14.611] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:14.611] info)
[21:39:14.611] }
[21:39:14.611] else {
[21:39:14.611] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:14.611] info, version)
[21:39:14.611] }
[21:39:14.611] base::stop(msg)
[21:39:14.611] }
[21:39:14.611] })
[21:39:14.611] }
[21:39:14.611] ...future.mc.cores.old <- base::getOption("mc.cores")
[21:39:14.611] base::options(mc.cores = 1L)
[21:39:14.611] }
[21:39:14.611] options(future.plan = NULL)
[21:39:14.611] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:14.611] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:14.611] }
[21:39:14.611] ...future.workdir <- getwd()
[21:39:14.611] }
[21:39:14.611] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:14.611] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:14.611] }
[21:39:14.611] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:14.611] future.globals.maxSize = NULL, future.globals.method = NULL,
[21:39:14.611] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:14.611] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:14.611] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:14.611] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:14.611] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:14.611] base::names(...future.oldOptions))
[21:39:14.611] }
[21:39:14.611] if (FALSE) {
[21:39:14.611] }
[21:39:14.611] else {
[21:39:14.611] if (FALSE) {
[21:39:14.611] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:14.611] open = "w")
[21:39:14.611] }
[21:39:14.611] else {
[21:39:14.611] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:14.611] windows = "NUL", "/dev/null"), open = "w")
[21:39:14.611] }
[21:39:14.611] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:14.611] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:14.611] base::sink(type = "output", split = FALSE)
[21:39:14.611] base::close(...future.stdout)
[21:39:14.611] }, add = TRUE)
[21:39:14.611] }
[21:39:14.611] ...future.frame <- base::sys.nframe()
[21:39:14.611] ...future.conditions <- base::list()
[21:39:14.611] ...future.rng <- base::globalenv()$.Random.seed
[21:39:14.611] if (FALSE) {
[21:39:14.611] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:14.611] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:14.611] }
[21:39:14.611] ...future.result <- base::tryCatch({
[21:39:14.611] base::withCallingHandlers({
[21:39:14.611] ...future.value <- base::withVisible(base::local({
[21:39:14.611] withCallingHandlers({
[21:39:14.611] {
[21:39:14.611] do.call(function(...) {
[21:39:14.611] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:14.611] if (!identical(...future.globals.maxSize.org,
[21:39:14.611] ...future.globals.maxSize)) {
[21:39:14.611] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:14.611] on.exit(options(oopts), add = TRUE)
[21:39:14.611] }
[21:39:14.611] {
[21:39:14.611] lapply(seq_along(...future.elements_ii),
[21:39:14.611] FUN = function(jj) {
[21:39:14.611] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:14.611] ...future.FUN(...future.X_jj, ...)
[21:39:14.611] })
[21:39:14.611] }
[21:39:14.611] }, args = future.call.arguments)
[21:39:14.611] }
[21:39:14.611] }, immediateCondition = function(cond) {
[21:39:14.611] save_rds <- function (object, pathname, ...)
[21:39:14.611] {
[21:39:14.611] pathname_tmp <- sprintf("%s.tmp", pathname)
[21:39:14.611] if (file_test("-f", pathname_tmp)) {
[21:39:14.611] fi_tmp <- file.info(pathname_tmp)
[21:39:14.611] stopf("Cannot save RDS file because a temporary save file already exists: %s (%0.f bytes; last modified on %s)",
[21:39:14.611] sQuote(pathname_tmp), fi_tmp[["size"]],
[21:39:14.611] fi_tmp[["mtime"]])
[21:39:14.611] }
[21:39:14.611] tryCatch({
[21:39:14.611] saveRDS(object, file = pathname_tmp, ...)
[21:39:14.611] }, error = function(ex) {
[21:39:14.611] msg <- conditionMessage(ex)
[21:39:14.611] fi_tmp <- file.info(pathname_tmp)
[21:39:14.611] msg <- sprintf("saveRDS() failed to save to temporary file %s (%.0f bytes; last modified on %s). The reason was: %s",
[21:39:14.611] sQuote(pathname_tmp), fi_tmp[["size"]],
[21:39:14.611] fi_tmp[["mtime"]], msg)
[21:39:14.611] ex$message <- msg
[21:39:14.611] stop(ex)
[21:39:14.611] })
[21:39:14.611] stopifnot(file_test("-f", pathname_tmp))
[21:39:14.611] res <- file.rename(from = pathname_tmp, to = pathname)
[21:39:14.611] if (!res || file_test("-f", pathname_tmp)) {
[21:39:14.611] fi_tmp <- file.info(pathname_tmp)
[21:39:14.611] fi <- file.info(pathname)
[21:39:14.611] msg <- sprintf("save_rds() failed to rename temporary save file %s (%0.f bytes; last modified on %s) to %s (%0.f bytes; last modified on %s)",
[21:39:14.611] sQuote(pathname_tmp), fi_tmp[["size"]],
[21:39:14.611] fi_tmp[["mtime"]], sQuote(pathname),
[21:39:14.611] fi[["size"]], fi[["mtime"]])
[21:39:14.611] stop(msg)
[21:39:14.611] }
[21:39:14.611] invisible(pathname)
[21:39:14.611] }
[21:39:14.611] saveImmediateCondition <- function (cond, path = immediateConditionsPath(rootPath = rootPath),
[21:39:14.611] rootPath = tempdir())
[21:39:14.611] {
[21:39:14.611] obj <- list(time = Sys.time(), condition = cond)
[21:39:14.611] file <- tempfile(pattern = class(cond)[1],
[21:39:14.611] tmpdir = path, fileext = ".rds")
[21:39:14.611] save_rds(obj, file)
[21:39:14.611] }
[21:39:14.611] saveImmediateCondition(cond, path = "/home/hornik/tmp/scratch/RtmpXshvah/.future/immediateConditions")
[21:39:14.611] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:14.611] {
[21:39:14.611] inherits <- base::inherits
[21:39:14.611] invokeRestart <- base::invokeRestart
[21:39:14.611] is.null <- base::is.null
[21:39:14.611] muffled <- FALSE
[21:39:14.611] if (inherits(cond, "message")) {
[21:39:14.611] muffled <- grepl(pattern, "muffleMessage")
[21:39:14.611] if (muffled)
[21:39:14.611] invokeRestart("muffleMessage")
[21:39:14.611] }
[21:39:14.611] else if (inherits(cond, "warning")) {
[21:39:14.611] muffled <- grepl(pattern, "muffleWarning")
[21:39:14.611] if (muffled)
[21:39:14.611] invokeRestart("muffleWarning")
[21:39:14.611] }
[21:39:14.611] else if (inherits(cond, "condition")) {
[21:39:14.611] if (!is.null(pattern)) {
[21:39:14.611] computeRestarts <- base::computeRestarts
[21:39:14.611] grepl <- base::grepl
[21:39:14.611] restarts <- computeRestarts(cond)
[21:39:14.611] for (restart in restarts) {
[21:39:14.611] name <- restart$name
[21:39:14.611] if (is.null(name))
[21:39:14.611] next
[21:39:14.611] if (!grepl(pattern, name))
[21:39:14.611] next
[21:39:14.611] invokeRestart(restart)
[21:39:14.611] muffled <- TRUE
[21:39:14.611] break
[21:39:14.611] }
[21:39:14.611] }
[21:39:14.611] }
[21:39:14.611] invisible(muffled)
[21:39:14.611] }
[21:39:14.611] muffleCondition(cond)
[21:39:14.611] })
[21:39:14.611] }))
[21:39:14.611] future::FutureResult(value = ...future.value$value,
[21:39:14.611] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:14.611] ...future.rng), globalenv = if (FALSE)
[21:39:14.611] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:14.611] ...future.globalenv.names))
[21:39:14.611] else NULL, started = ...future.startTime, version = "1.8")
[21:39:14.611] }, condition = base::local({
[21:39:14.611] c <- base::c
[21:39:14.611] inherits <- base::inherits
[21:39:14.611] invokeRestart <- base::invokeRestart
[21:39:14.611] length <- base::length
[21:39:14.611] list <- base::list
[21:39:14.611] seq.int <- base::seq.int
[21:39:14.611] signalCondition <- base::signalCondition
[21:39:14.611] sys.calls <- base::sys.calls
[21:39:14.611] `[[` <- base::`[[`
[21:39:14.611] `+` <- base::`+`
[21:39:14.611] `<<-` <- base::`<<-`
[21:39:14.611] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:14.611] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:14.611] 3L)]
[21:39:14.611] }
[21:39:14.611] function(cond) {
[21:39:14.611] is_error <- inherits(cond, "error")
[21:39:14.611] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:14.611] NULL)
[21:39:14.611] if (is_error) {
[21:39:14.611] sessionInformation <- function() {
[21:39:14.611] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:14.611] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:14.611] search = base::search(), system = base::Sys.info())
[21:39:14.611] }
[21:39:14.611] ...future.conditions[[length(...future.conditions) +
[21:39:14.611] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:14.611] cond$call), session = sessionInformation(),
[21:39:14.611] timestamp = base::Sys.time(), signaled = 0L)
[21:39:14.611] signalCondition(cond)
[21:39:14.611] }
[21:39:14.611] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:14.611] "immediateCondition"))) {
[21:39:14.611] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:14.611] ...future.conditions[[length(...future.conditions) +
[21:39:14.611] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:14.611] if (TRUE && !signal) {
[21:39:14.611] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:14.611] {
[21:39:14.611] inherits <- base::inherits
[21:39:14.611] invokeRestart <- base::invokeRestart
[21:39:14.611] is.null <- base::is.null
[21:39:14.611] muffled <- FALSE
[21:39:14.611] if (inherits(cond, "message")) {
[21:39:14.611] muffled <- grepl(pattern, "muffleMessage")
[21:39:14.611] if (muffled)
[21:39:14.611] invokeRestart("muffleMessage")
[21:39:14.611] }
[21:39:14.611] else if (inherits(cond, "warning")) {
[21:39:14.611] muffled <- grepl(pattern, "muffleWarning")
[21:39:14.611] if (muffled)
[21:39:14.611] invokeRestart("muffleWarning")
[21:39:14.611] }
[21:39:14.611] else if (inherits(cond, "condition")) {
[21:39:14.611] if (!is.null(pattern)) {
[21:39:14.611] computeRestarts <- base::computeRestarts
[21:39:14.611] grepl <- base::grepl
[21:39:14.611] restarts <- computeRestarts(cond)
[21:39:14.611] for (restart in restarts) {
[21:39:14.611] name <- restart$name
[21:39:14.611] if (is.null(name))
[21:39:14.611] next
[21:39:14.611] if (!grepl(pattern, name))
[21:39:14.611] next
[21:39:14.611] invokeRestart(restart)
[21:39:14.611] muffled <- TRUE
[21:39:14.611] break
[21:39:14.611] }
[21:39:14.611] }
[21:39:14.611] }
[21:39:14.611] invisible(muffled)
[21:39:14.611] }
[21:39:14.611] muffleCondition(cond, pattern = "^muffle")
[21:39:14.611] }
[21:39:14.611] }
[21:39:14.611] else {
[21:39:14.611] if (TRUE) {
[21:39:14.611] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:14.611] {
[21:39:14.611] inherits <- base::inherits
[21:39:14.611] invokeRestart <- base::invokeRestart
[21:39:14.611] is.null <- base::is.null
[21:39:14.611] muffled <- FALSE
[21:39:14.611] if (inherits(cond, "message")) {
[21:39:14.611] muffled <- grepl(pattern, "muffleMessage")
[21:39:14.611] if (muffled)
[21:39:14.611] invokeRestart("muffleMessage")
[21:39:14.611] }
[21:39:14.611] else if (inherits(cond, "warning")) {
[21:39:14.611] muffled <- grepl(pattern, "muffleWarning")
[21:39:14.611] if (muffled)
[21:39:14.611] invokeRestart("muffleWarning")
[21:39:14.611] }
[21:39:14.611] else if (inherits(cond, "condition")) {
[21:39:14.611] if (!is.null(pattern)) {
[21:39:14.611] computeRestarts <- base::computeRestarts
[21:39:14.611] grepl <- base::grepl
[21:39:14.611] restarts <- computeRestarts(cond)
[21:39:14.611] for (restart in restarts) {
[21:39:14.611] name <- restart$name
[21:39:14.611] if (is.null(name))
[21:39:14.611] next
[21:39:14.611] if (!grepl(pattern, name))
[21:39:14.611] next
[21:39:14.611] invokeRestart(restart)
[21:39:14.611] muffled <- TRUE
[21:39:14.611] break
[21:39:14.611] }
[21:39:14.611] }
[21:39:14.611] }
[21:39:14.611] invisible(muffled)
[21:39:14.611] }
[21:39:14.611] muffleCondition(cond, pattern = "^muffle")
[21:39:14.611] }
[21:39:14.611] }
[21:39:14.611] }
[21:39:14.611] }))
[21:39:14.611] }, error = function(ex) {
[21:39:14.611] base::structure(base::list(value = NULL, visible = NULL,
[21:39:14.611] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:14.611] ...future.rng), started = ...future.startTime,
[21:39:14.611] finished = Sys.time(), session_uuid = NA_character_,
[21:39:14.611] version = "1.8"), class = "FutureResult")
[21:39:14.611] }, finally = {
[21:39:14.611] if (!identical(...future.workdir, getwd()))
[21:39:14.611] setwd(...future.workdir)
[21:39:14.611] {
[21:39:14.611] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:14.611] ...future.oldOptions$nwarnings <- NULL
[21:39:14.611] }
[21:39:14.611] base::options(...future.oldOptions)
[21:39:14.611] if (.Platform$OS.type == "windows") {
[21:39:14.611] old_names <- names(...future.oldEnvVars)
[21:39:14.611] envs <- base::Sys.getenv()
[21:39:14.611] names <- names(envs)
[21:39:14.611] common <- intersect(names, old_names)
[21:39:14.611] added <- setdiff(names, old_names)
[21:39:14.611] removed <- setdiff(old_names, names)
[21:39:14.611] changed <- common[...future.oldEnvVars[common] !=
[21:39:14.611] envs[common]]
[21:39:14.611] NAMES <- toupper(changed)
[21:39:14.611] args <- list()
[21:39:14.611] for (kk in seq_along(NAMES)) {
[21:39:14.611] name <- changed[[kk]]
[21:39:14.611] NAME <- NAMES[[kk]]
[21:39:14.611] if (name != NAME && is.element(NAME, old_names))
[21:39:14.611] next
[21:39:14.611] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:14.611] }
[21:39:14.611] NAMES <- toupper(added)
[21:39:14.611] for (kk in seq_along(NAMES)) {
[21:39:14.611] name <- added[[kk]]
[21:39:14.611] NAME <- NAMES[[kk]]
[21:39:14.611] if (name != NAME && is.element(NAME, old_names))
[21:39:14.611] next
[21:39:14.611] args[[name]] <- ""
[21:39:14.611] }
[21:39:14.611] NAMES <- toupper(removed)
[21:39:14.611] for (kk in seq_along(NAMES)) {
[21:39:14.611] name <- removed[[kk]]
[21:39:14.611] NAME <- NAMES[[kk]]
[21:39:14.611] if (name != NAME && is.element(NAME, old_names))
[21:39:14.611] next
[21:39:14.611] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:14.611] }
[21:39:14.611] if (length(args) > 0)
[21:39:14.611] base::do.call(base::Sys.setenv, args = args)
[21:39:14.611] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:14.611] }
[21:39:14.611] else {
[21:39:14.611] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:14.611] }
[21:39:14.611] {
[21:39:14.611] if (base::length(...future.futureOptionsAdded) >
[21:39:14.611] 0L) {
[21:39:14.611] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:14.611] base::names(opts) <- ...future.futureOptionsAdded
[21:39:14.611] base::options(opts)
[21:39:14.611] }
[21:39:14.611] {
[21:39:14.611] {
[21:39:14.611] base::options(mc.cores = ...future.mc.cores.old)
[21:39:14.611] NULL
[21:39:14.611] }
[21:39:14.611] options(future.plan = NULL)
[21:39:14.611] if (is.na(NA_character_))
[21:39:14.611] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:14.611] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:14.611] future::plan(list(function (..., workers = availableCores(constraints = "multicore"),
[21:39:14.611] envir = parent.frame())
[21:39:14.611] {
[21:39:14.611] default_workers <- missing(workers)
[21:39:14.611] if (is.function(workers))
[21:39:14.611] workers <- workers()
[21:39:14.611] workers <- structure(as.integer(workers),
[21:39:14.611] class = class(workers))
[21:39:14.611] stop_if_not(is.finite(workers), workers >=
[21:39:14.611] 1L)
[21:39:14.611] if ((workers == 1L && !inherits(workers,
[21:39:14.611] "AsIs")) || !supportsMulticore(warn = TRUE)) {
[21:39:14.611] if (default_workers)
[21:39:14.611] supportsMulticore(warn = TRUE)
[21:39:14.611] return(sequential(..., envir = envir))
[21:39:14.611] }
[21:39:14.611] oopts <- options(mc.cores = workers)
[21:39:14.611] on.exit(options(oopts))
[21:39:14.611] future <- MulticoreFuture(..., workers = workers,
[21:39:14.611] envir = envir)
[21:39:14.611] if (!future$lazy)
[21:39:14.611] future <- run(future)
[21:39:14.611] invisible(future)
[21:39:14.611] }), .cleanup = FALSE, .init = FALSE)
[21:39:14.611] }
[21:39:14.611] }
[21:39:14.611] }
[21:39:14.611] })
[21:39:14.611] if (TRUE) {
[21:39:14.611] base::sink(type = "output", split = FALSE)
[21:39:14.611] if (FALSE) {
[21:39:14.611] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:14.611] }
[21:39:14.611] else {
[21:39:14.611] ...future.result["stdout"] <- base::list(NULL)
[21:39:14.611] }
[21:39:14.611] base::close(...future.stdout)
[21:39:14.611] ...future.stdout <- NULL
[21:39:14.611] }
[21:39:14.611] ...future.result$conditions <- ...future.conditions
[21:39:14.611] ...future.result$finished <- base::Sys.time()
[21:39:14.611] ...future.result
[21:39:14.611] }
[21:39:14.649] assign_globals() ...
[21:39:14.649] List of 5
[21:39:14.649] $ ...future.FUN :function (x)
[21:39:14.649] $ future.call.arguments : list()
[21:39:14.649] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:14.649] $ ...future.elements_ii :List of 1
[21:39:14.649] ..$ : int 1
[21:39:14.649] $ ...future.seeds_ii : NULL
[21:39:14.649] $ ...future.globals.maxSize: NULL
[21:39:14.649] - attr(*, "where")=List of 5
[21:39:14.649] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:14.649] ..$ future.call.arguments :<environment: R_EmptyEnv>
[21:39:14.649] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:14.649] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:14.649] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:14.649] - attr(*, "resolved")= logi FALSE
[21:39:14.649] - attr(*, "total_size")= num 4720
[21:39:14.649] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:14.649] - attr(*, "already-done")= logi TRUE
[21:39:14.660] - reassign environment for '...future.FUN'
[21:39:14.661] - copied '...future.FUN' to environment
[21:39:14.661] - copied 'future.call.arguments' to environment
[21:39:14.661] - copied '...future.elements_ii' to environment
[21:39:14.662] - copied '...future.seeds_ii' to environment
[21:39:14.662] - copied '...future.globals.maxSize' to environment
[21:39:14.662] assign_globals() ... done
[21:39:14.679] requestCore(): workers = 2
[21:39:14.683] MulticoreFuture started
[21:39:14.684] - Launch lazy future ... done
[21:39:14.684] run() for 'MulticoreFuture' ... done
[21:39:14.685] Created future:
[21:39:14.692] plan(): Setting new future strategy stack:
[21:39:14.693] List of future strategies:
[21:39:14.693] 1. sequential:
[21:39:14.693] - args: function (..., envir = parent.frame())
[21:39:14.693] - tweaked: FALSE
[21:39:14.693] - call: NULL
[21:39:14.694] plan(): nbrOfWorkers() = 1
[21:39:14.685] MulticoreFuture:
[21:39:14.685] Label: 'future_lapply-1'
[21:39:14.685] Expression:
[21:39:14.685] {
[21:39:14.685] do.call(function(...) {
[21:39:14.685] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:14.685] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:14.685] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:14.685] on.exit(options(oopts), add = TRUE)
[21:39:14.685] }
[21:39:14.685] {
[21:39:14.685] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:14.685] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:14.685] ...future.FUN(...future.X_jj, ...)
[21:39:14.685] })
[21:39:14.685] }
[21:39:14.685] }, args = future.call.arguments)
[21:39:14.685] }
[21:39:14.685] Lazy evaluation: FALSE
[21:39:14.685] Asynchronous evaluation: TRUE
[21:39:14.685] Local evaluation: TRUE
[21:39:14.685] Environment: R_GlobalEnv
[21:39:14.685] Capture standard output: FALSE
[21:39:14.685] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:14.685] Globals: 5 objects totaling 4.66 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:14.685] Packages: <none>
[21:39:14.685] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:14.685] Resolved: FALSE
[21:39:14.685] Value: <not collected>
[21:39:14.685] Conditions captured: <none>
[21:39:14.685] Early signaling: FALSE
[21:39:14.685] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:14.685] Class: 'MulticoreFuture', 'MultiprocessFuture', 'Future', 'environment'
[21:39:14.703] Chunk #1 of 2 ... DONE
[21:39:14.703] Chunk #2 of 2 ...
[21:39:14.704] - Finding globals in 'X' for chunk #2 ...
[21:39:14.704] getGlobalsAndPackages() ...
[21:39:14.704] Searching for globals...
[21:39:14.705]
[21:39:14.705] Searching for globals ... DONE
[21:39:14.706] - globals: [0] <none>
[21:39:14.706] getGlobalsAndPackages() ... DONE
[21:39:14.706] + additional globals found: [n=0]
[21:39:14.707] + additional namespaces needed: [n=0]
[21:39:14.707] - Finding globals in 'X' for chunk #2 ... DONE
[21:39:14.707] - seeds: <none>
[21:39:14.708] getGlobalsAndPackages() ...
[21:39:14.708] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:14.708] Resolving globals: FALSE
[21:39:14.709] Tweak future expression to call with '...' arguments ...
[21:39:14.709] {
[21:39:14.709] do.call(function(...) {
[21:39:14.709] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:14.709] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:14.709] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:14.709] on.exit(options(oopts), add = TRUE)
[21:39:14.709] }
[21:39:14.709] {
[21:39:14.709] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:14.709] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:14.709] ...future.FUN(...future.X_jj, ...)
[21:39:14.709] })
[21:39:14.709] }
[21:39:14.709] }, args = future.call.arguments)
[21:39:14.709] }
[21:39:14.710] Tweak future expression to call with '...' arguments ... DONE
[21:39:14.711] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[21:39:14.711]
[21:39:14.712] getGlobalsAndPackages() ... DONE
[21:39:14.713] run() for 'Future' ...
[21:39:14.713] - state: 'created'
[21:39:14.713] - Future backend: 'FutureStrategy', 'multicore', 'multiprocess', 'future', 'function'
[21:39:14.763] - Future class: 'MulticoreFuture', 'MultiprocessFuture', 'Future', 'environment'
[21:39:14.764] - Copy elements of temporary 'MulticoreFuture' to final 'Future' object ...
[21:39:14.764] - Field: 'label'
[21:39:14.764] - Field: 'local'
[21:39:14.765] - Field: 'owner'
[21:39:14.765] - Field: 'envir'
[21:39:14.765] - Field: 'workers'
[21:39:14.765] - Field: 'packages'
[21:39:14.766] - Field: 'gc'
[21:39:14.766] - Field: 'job'
[21:39:14.766] - Field: 'conditions'
[21:39:14.767] - Field: 'expr'
[21:39:14.767] - Field: 'uuid'
[21:39:14.767] - Field: 'seed'
[21:39:14.767] - Field: 'version'
[21:39:14.768] - Field: 'result'
[21:39:14.768] - Field: 'asynchronous'
[21:39:14.768] - Field: 'calls'
[21:39:14.768] - Field: 'globals'
[21:39:14.769] - Field: 'stdout'
[21:39:14.769] - Field: 'earlySignal'
[21:39:14.769] - Field: 'lazy'
[21:39:14.769] - Field: 'state'
[21:39:14.770] - Copy elements of temporary 'MulticoreFuture' to final 'Future' object ... done
[21:39:14.770] - Launch lazy future ...
[21:39:14.771] Packages needed by the future expression (n = 0): <none>
[21:39:14.794] Packages needed by future strategies (n = 0): <none>
[21:39:14.796] {
[21:39:14.796] {
[21:39:14.796] {
[21:39:14.796] ...future.startTime <- base::Sys.time()
[21:39:14.796] {
[21:39:14.796] {
[21:39:14.796] {
[21:39:14.796] {
[21:39:14.796] base::local({
[21:39:14.796] has_future <- base::requireNamespace("future",
[21:39:14.796] quietly = TRUE)
[21:39:14.796] if (has_future) {
[21:39:14.796] ns <- base::getNamespace("future")
[21:39:14.796] version <- ns[[".package"]][["version"]]
[21:39:14.796] if (is.null(version))
[21:39:14.796] version <- utils::packageVersion("future")
[21:39:14.796] }
[21:39:14.796] else {
[21:39:14.796] version <- NULL
[21:39:14.796] }
[21:39:14.796] if (!has_future || version < "1.8.0") {
[21:39:14.796] info <- base::c(r_version = base::gsub("R version ",
[21:39:14.796] "", base::R.version$version.string),
[21:39:14.796] platform = base::sprintf("%s (%s-bit)",
[21:39:14.796] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[21:39:14.796] os = base::paste(base::Sys.info()[base::c("sysname",
[21:39:14.796] "release", "version")], collapse = " "),
[21:39:14.796] hostname = base::Sys.info()[["nodename"]])
[21:39:14.796] info <- base::sprintf("%s: %s", base::names(info),
[21:39:14.796] info)
[21:39:14.796] info <- base::paste(info, collapse = "; ")
[21:39:14.796] if (!has_future) {
[21:39:14.796] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[21:39:14.796] info)
[21:39:14.796] }
[21:39:14.796] else {
[21:39:14.796] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[21:39:14.796] info, version)
[21:39:14.796] }
[21:39:14.796] base::stop(msg)
[21:39:14.796] }
[21:39:14.796] })
[21:39:14.796] }
[21:39:14.796] ...future.mc.cores.old <- base::getOption("mc.cores")
[21:39:14.796] base::options(mc.cores = 1L)
[21:39:14.796] }
[21:39:14.796] options(future.plan = NULL)
[21:39:14.796] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:14.796] future::plan("default", .cleanup = FALSE, .init = FALSE)
[21:39:14.796] }
[21:39:14.796] ...future.workdir <- getwd()
[21:39:14.796] }
[21:39:14.796] ...future.oldOptions <- base::as.list(base::.Options)
[21:39:14.796] ...future.oldEnvVars <- base::Sys.getenv()
[21:39:14.796] }
[21:39:14.796] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[21:39:14.796] future.globals.maxSize = NULL, future.globals.method = NULL,
[21:39:14.796] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[21:39:14.796] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[21:39:14.796] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[21:39:14.796] future.stdout.windows.reencode = NULL, width = 80L)
[21:39:14.796] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[21:39:14.796] base::names(...future.oldOptions))
[21:39:14.796] }
[21:39:14.796] if (FALSE) {
[21:39:14.796] }
[21:39:14.796] else {
[21:39:14.796] if (FALSE) {
[21:39:14.796] ...future.stdout <- base::rawConnection(base::raw(0L),
[21:39:14.796] open = "w")
[21:39:14.796] }
[21:39:14.796] else {
[21:39:14.796] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[21:39:14.796] windows = "NUL", "/dev/null"), open = "w")
[21:39:14.796] }
[21:39:14.796] base::sink(...future.stdout, type = "output", split = FALSE)
[21:39:14.796] base::on.exit(if (!base::is.null(...future.stdout)) {
[21:39:14.796] base::sink(type = "output", split = FALSE)
[21:39:14.796] base::close(...future.stdout)
[21:39:14.796] }, add = TRUE)
[21:39:14.796] }
[21:39:14.796] ...future.frame <- base::sys.nframe()
[21:39:14.796] ...future.conditions <- base::list()
[21:39:14.796] ...future.rng <- base::globalenv()$.Random.seed
[21:39:14.796] if (FALSE) {
[21:39:14.796] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[21:39:14.796] "...future.value", "...future.globalenv.names", ".Random.seed")
[21:39:14.796] }
[21:39:14.796] ...future.result <- base::tryCatch({
[21:39:14.796] base::withCallingHandlers({
[21:39:14.796] ...future.value <- base::withVisible(base::local({
[21:39:14.796] withCallingHandlers({
[21:39:14.796] {
[21:39:14.796] do.call(function(...) {
[21:39:14.796] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:14.796] if (!identical(...future.globals.maxSize.org,
[21:39:14.796] ...future.globals.maxSize)) {
[21:39:14.796] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:14.796] on.exit(options(oopts), add = TRUE)
[21:39:14.796] }
[21:39:14.796] {
[21:39:14.796] lapply(seq_along(...future.elements_ii),
[21:39:14.796] FUN = function(jj) {
[21:39:14.796] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:14.796] ...future.FUN(...future.X_jj, ...)
[21:39:14.796] })
[21:39:14.796] }
[21:39:14.796] }, args = future.call.arguments)
[21:39:14.796] }
[21:39:14.796] }, immediateCondition = function(cond) {
[21:39:14.796] save_rds <- function (object, pathname, ...)
[21:39:14.796] {
[21:39:14.796] pathname_tmp <- sprintf("%s.tmp", pathname)
[21:39:14.796] if (file_test("-f", pathname_tmp)) {
[21:39:14.796] fi_tmp <- file.info(pathname_tmp)
[21:39:14.796] stopf("Cannot save RDS file because a temporary save file already exists: %s (%0.f bytes; last modified on %s)",
[21:39:14.796] sQuote(pathname_tmp), fi_tmp[["size"]],
[21:39:14.796] fi_tmp[["mtime"]])
[21:39:14.796] }
[21:39:14.796] tryCatch({
[21:39:14.796] saveRDS(object, file = pathname_tmp, ...)
[21:39:14.796] }, error = function(ex) {
[21:39:14.796] msg <- conditionMessage(ex)
[21:39:14.796] fi_tmp <- file.info(pathname_tmp)
[21:39:14.796] msg <- sprintf("saveRDS() failed to save to temporary file %s (%.0f bytes; last modified on %s). The reason was: %s",
[21:39:14.796] sQuote(pathname_tmp), fi_tmp[["size"]],
[21:39:14.796] fi_tmp[["mtime"]], msg)
[21:39:14.796] ex$message <- msg
[21:39:14.796] stop(ex)
[21:39:14.796] })
[21:39:14.796] stopifnot(file_test("-f", pathname_tmp))
[21:39:14.796] res <- file.rename(from = pathname_tmp, to = pathname)
[21:39:14.796] if (!res || file_test("-f", pathname_tmp)) {
[21:39:14.796] fi_tmp <- file.info(pathname_tmp)
[21:39:14.796] fi <- file.info(pathname)
[21:39:14.796] msg <- sprintf("save_rds() failed to rename temporary save file %s (%0.f bytes; last modified on %s) to %s (%0.f bytes; last modified on %s)",
[21:39:14.796] sQuote(pathname_tmp), fi_tmp[["size"]],
[21:39:14.796] fi_tmp[["mtime"]], sQuote(pathname),
[21:39:14.796] fi[["size"]], fi[["mtime"]])
[21:39:14.796] stop(msg)
[21:39:14.796] }
[21:39:14.796] invisible(pathname)
[21:39:14.796] }
[21:39:14.796] saveImmediateCondition <- function (cond, path = immediateConditionsPath(rootPath = rootPath),
[21:39:14.796] rootPath = tempdir())
[21:39:14.796] {
[21:39:14.796] obj <- list(time = Sys.time(), condition = cond)
[21:39:14.796] file <- tempfile(pattern = class(cond)[1],
[21:39:14.796] tmpdir = path, fileext = ".rds")
[21:39:14.796] save_rds(obj, file)
[21:39:14.796] }
[21:39:14.796] saveImmediateCondition(cond, path = "/home/hornik/tmp/scratch/RtmpXshvah/.future/immediateConditions")
[21:39:14.796] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:14.796] {
[21:39:14.796] inherits <- base::inherits
[21:39:14.796] invokeRestart <- base::invokeRestart
[21:39:14.796] is.null <- base::is.null
[21:39:14.796] muffled <- FALSE
[21:39:14.796] if (inherits(cond, "message")) {
[21:39:14.796] muffled <- grepl(pattern, "muffleMessage")
[21:39:14.796] if (muffled)
[21:39:14.796] invokeRestart("muffleMessage")
[21:39:14.796] }
[21:39:14.796] else if (inherits(cond, "warning")) {
[21:39:14.796] muffled <- grepl(pattern, "muffleWarning")
[21:39:14.796] if (muffled)
[21:39:14.796] invokeRestart("muffleWarning")
[21:39:14.796] }
[21:39:14.796] else if (inherits(cond, "condition")) {
[21:39:14.796] if (!is.null(pattern)) {
[21:39:14.796] computeRestarts <- base::computeRestarts
[21:39:14.796] grepl <- base::grepl
[21:39:14.796] restarts <- computeRestarts(cond)
[21:39:14.796] for (restart in restarts) {
[21:39:14.796] name <- restart$name
[21:39:14.796] if (is.null(name))
[21:39:14.796] next
[21:39:14.796] if (!grepl(pattern, name))
[21:39:14.796] next
[21:39:14.796] invokeRestart(restart)
[21:39:14.796] muffled <- TRUE
[21:39:14.796] break
[21:39:14.796] }
[21:39:14.796] }
[21:39:14.796] }
[21:39:14.796] invisible(muffled)
[21:39:14.796] }
[21:39:14.796] muffleCondition(cond)
[21:39:14.796] })
[21:39:14.796] }))
[21:39:14.796] future::FutureResult(value = ...future.value$value,
[21:39:14.796] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[21:39:14.796] ...future.rng), globalenv = if (FALSE)
[21:39:14.796] list(added = base::setdiff(base::names(base::.GlobalEnv),
[21:39:14.796] ...future.globalenv.names))
[21:39:14.796] else NULL, started = ...future.startTime, version = "1.8")
[21:39:14.796] }, condition = base::local({
[21:39:14.796] c <- base::c
[21:39:14.796] inherits <- base::inherits
[21:39:14.796] invokeRestart <- base::invokeRestart
[21:39:14.796] length <- base::length
[21:39:14.796] list <- base::list
[21:39:14.796] seq.int <- base::seq.int
[21:39:14.796] signalCondition <- base::signalCondition
[21:39:14.796] sys.calls <- base::sys.calls
[21:39:14.796] `[[` <- base::`[[`
[21:39:14.796] `+` <- base::`+`
[21:39:14.796] `<<-` <- base::`<<-`
[21:39:14.796] sysCalls <- function(calls = sys.calls(), from = 1L) {
[21:39:14.796] calls[seq.int(from = from + 12L, to = length(calls) -
[21:39:14.796] 3L)]
[21:39:14.796] }
[21:39:14.796] function(cond) {
[21:39:14.796] is_error <- inherits(cond, "error")
[21:39:14.796] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[21:39:14.796] NULL)
[21:39:14.796] if (is_error) {
[21:39:14.796] sessionInformation <- function() {
[21:39:14.796] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[21:39:14.796] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[21:39:14.796] search = base::search(), system = base::Sys.info())
[21:39:14.796] }
[21:39:14.796] ...future.conditions[[length(...future.conditions) +
[21:39:14.796] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[21:39:14.796] cond$call), session = sessionInformation(),
[21:39:14.796] timestamp = base::Sys.time(), signaled = 0L)
[21:39:14.796] signalCondition(cond)
[21:39:14.796] }
[21:39:14.796] else if (!ignore && TRUE && inherits(cond, c("condition",
[21:39:14.796] "immediateCondition"))) {
[21:39:14.796] signal <- TRUE && inherits(cond, "immediateCondition")
[21:39:14.796] ...future.conditions[[length(...future.conditions) +
[21:39:14.796] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[21:39:14.796] if (TRUE && !signal) {
[21:39:14.796] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:14.796] {
[21:39:14.796] inherits <- base::inherits
[21:39:14.796] invokeRestart <- base::invokeRestart
[21:39:14.796] is.null <- base::is.null
[21:39:14.796] muffled <- FALSE
[21:39:14.796] if (inherits(cond, "message")) {
[21:39:14.796] muffled <- grepl(pattern, "muffleMessage")
[21:39:14.796] if (muffled)
[21:39:14.796] invokeRestart("muffleMessage")
[21:39:14.796] }
[21:39:14.796] else if (inherits(cond, "warning")) {
[21:39:14.796] muffled <- grepl(pattern, "muffleWarning")
[21:39:14.796] if (muffled)
[21:39:14.796] invokeRestart("muffleWarning")
[21:39:14.796] }
[21:39:14.796] else if (inherits(cond, "condition")) {
[21:39:14.796] if (!is.null(pattern)) {
[21:39:14.796] computeRestarts <- base::computeRestarts
[21:39:14.796] grepl <- base::grepl
[21:39:14.796] restarts <- computeRestarts(cond)
[21:39:14.796] for (restart in restarts) {
[21:39:14.796] name <- restart$name
[21:39:14.796] if (is.null(name))
[21:39:14.796] next
[21:39:14.796] if (!grepl(pattern, name))
[21:39:14.796] next
[21:39:14.796] invokeRestart(restart)
[21:39:14.796] muffled <- TRUE
[21:39:14.796] break
[21:39:14.796] }
[21:39:14.796] }
[21:39:14.796] }
[21:39:14.796] invisible(muffled)
[21:39:14.796] }
[21:39:14.796] muffleCondition(cond, pattern = "^muffle")
[21:39:14.796] }
[21:39:14.796] }
[21:39:14.796] else {
[21:39:14.796] if (TRUE) {
[21:39:14.796] muffleCondition <- function (cond, pattern = "^muffle")
[21:39:14.796] {
[21:39:14.796] inherits <- base::inherits
[21:39:14.796] invokeRestart <- base::invokeRestart
[21:39:14.796] is.null <- base::is.null
[21:39:14.796] muffled <- FALSE
[21:39:14.796] if (inherits(cond, "message")) {
[21:39:14.796] muffled <- grepl(pattern, "muffleMessage")
[21:39:14.796] if (muffled)
[21:39:14.796] invokeRestart("muffleMessage")
[21:39:14.796] }
[21:39:14.796] else if (inherits(cond, "warning")) {
[21:39:14.796] muffled <- grepl(pattern, "muffleWarning")
[21:39:14.796] if (muffled)
[21:39:14.796] invokeRestart("muffleWarning")
[21:39:14.796] }
[21:39:14.796] else if (inherits(cond, "condition")) {
[21:39:14.796] if (!is.null(pattern)) {
[21:39:14.796] computeRestarts <- base::computeRestarts
[21:39:14.796] grepl <- base::grepl
[21:39:14.796] restarts <- computeRestarts(cond)
[21:39:14.796] for (restart in restarts) {
[21:39:14.796] name <- restart$name
[21:39:14.796] if (is.null(name))
[21:39:14.796] next
[21:39:14.796] if (!grepl(pattern, name))
[21:39:14.796] next
[21:39:14.796] invokeRestart(restart)
[21:39:14.796] muffled <- TRUE
[21:39:14.796] break
[21:39:14.796] }
[21:39:14.796] }
[21:39:14.796] }
[21:39:14.796] invisible(muffled)
[21:39:14.796] }
[21:39:14.796] muffleCondition(cond, pattern = "^muffle")
[21:39:14.796] }
[21:39:14.796] }
[21:39:14.796] }
[21:39:14.796] }))
[21:39:14.796] }, error = function(ex) {
[21:39:14.796] base::structure(base::list(value = NULL, visible = NULL,
[21:39:14.796] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[21:39:14.796] ...future.rng), started = ...future.startTime,
[21:39:14.796] finished = Sys.time(), session_uuid = NA_character_,
[21:39:14.796] version = "1.8"), class = "FutureResult")
[21:39:14.796] }, finally = {
[21:39:14.796] if (!identical(...future.workdir, getwd()))
[21:39:14.796] setwd(...future.workdir)
[21:39:14.796] {
[21:39:14.796] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[21:39:14.796] ...future.oldOptions$nwarnings <- NULL
[21:39:14.796] }
[21:39:14.796] base::options(...future.oldOptions)
[21:39:14.796] if (.Platform$OS.type == "windows") {
[21:39:14.796] old_names <- names(...future.oldEnvVars)
[21:39:14.796] envs <- base::Sys.getenv()
[21:39:14.796] names <- names(envs)
[21:39:14.796] common <- intersect(names, old_names)
[21:39:14.796] added <- setdiff(names, old_names)
[21:39:14.796] removed <- setdiff(old_names, names)
[21:39:14.796] changed <- common[...future.oldEnvVars[common] !=
[21:39:14.796] envs[common]]
[21:39:14.796] NAMES <- toupper(changed)
[21:39:14.796] args <- list()
[21:39:14.796] for (kk in seq_along(NAMES)) {
[21:39:14.796] name <- changed[[kk]]
[21:39:14.796] NAME <- NAMES[[kk]]
[21:39:14.796] if (name != NAME && is.element(NAME, old_names))
[21:39:14.796] next
[21:39:14.796] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:14.796] }
[21:39:14.796] NAMES <- toupper(added)
[21:39:14.796] for (kk in seq_along(NAMES)) {
[21:39:14.796] name <- added[[kk]]
[21:39:14.796] NAME <- NAMES[[kk]]
[21:39:14.796] if (name != NAME && is.element(NAME, old_names))
[21:39:14.796] next
[21:39:14.796] args[[name]] <- ""
[21:39:14.796] }
[21:39:14.796] NAMES <- toupper(removed)
[21:39:14.796] for (kk in seq_along(NAMES)) {
[21:39:14.796] name <- removed[[kk]]
[21:39:14.796] NAME <- NAMES[[kk]]
[21:39:14.796] if (name != NAME && is.element(NAME, old_names))
[21:39:14.796] next
[21:39:14.796] args[[name]] <- ...future.oldEnvVars[[name]]
[21:39:14.796] }
[21:39:14.796] if (length(args) > 0)
[21:39:14.796] base::do.call(base::Sys.setenv, args = args)
[21:39:14.796] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[21:39:14.796] }
[21:39:14.796] else {
[21:39:14.796] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[21:39:14.796] }
[21:39:14.796] {
[21:39:14.796] if (base::length(...future.futureOptionsAdded) >
[21:39:14.796] 0L) {
[21:39:14.796] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[21:39:14.796] base::names(opts) <- ...future.futureOptionsAdded
[21:39:14.796] base::options(opts)
[21:39:14.796] }
[21:39:14.796] {
[21:39:14.796] {
[21:39:14.796] base::options(mc.cores = ...future.mc.cores.old)
[21:39:14.796] NULL
[21:39:14.796] }
[21:39:14.796] options(future.plan = NULL)
[21:39:14.796] if (is.na(NA_character_))
[21:39:14.796] Sys.unsetenv("R_FUTURE_PLAN")
[21:39:14.796] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[21:39:14.796] future::plan(list(function (..., workers = availableCores(constraints = "multicore"),
[21:39:14.796] envir = parent.frame())
[21:39:14.796] {
[21:39:14.796] default_workers <- missing(workers)
[21:39:14.796] if (is.function(workers))
[21:39:14.796] workers <- workers()
[21:39:14.796] workers <- structure(as.integer(workers),
[21:39:14.796] class = class(workers))
[21:39:14.796] stop_if_not(is.finite(workers), workers >=
[21:39:14.796] 1L)
[21:39:14.796] if ((workers == 1L && !inherits(workers,
[21:39:14.796] "AsIs")) || !supportsMulticore(warn = TRUE)) {
[21:39:14.796] if (default_workers)
[21:39:14.796] supportsMulticore(warn = TRUE)
[21:39:14.796] return(sequential(..., envir = envir))
[21:39:14.796] }
[21:39:14.796] oopts <- options(mc.cores = workers)
[21:39:14.796] on.exit(options(oopts))
[21:39:14.796] future <- MulticoreFuture(..., workers = workers,
[21:39:14.796] envir = envir)
[21:39:14.796] if (!future$lazy)
[21:39:14.796] future <- run(future)
[21:39:14.796] invisible(future)
[21:39:14.796] }), .cleanup = FALSE, .init = FALSE)
[21:39:14.796] }
[21:39:14.796] }
[21:39:14.796] }
[21:39:14.796] })
[21:39:14.796] if (TRUE) {
[21:39:14.796] base::sink(type = "output", split = FALSE)
[21:39:14.796] if (FALSE) {
[21:39:14.796] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[21:39:14.796] }
[21:39:14.796] else {
[21:39:14.796] ...future.result["stdout"] <- base::list(NULL)
[21:39:14.796] }
[21:39:14.796] base::close(...future.stdout)
[21:39:14.796] ...future.stdout <- NULL
[21:39:14.796] }
[21:39:14.796] ...future.result$conditions <- ...future.conditions
[21:39:14.796] ...future.result$finished <- base::Sys.time()
[21:39:14.796] ...future.result
[21:39:14.796] }
[21:39:14.801] assign_globals() ...
[21:39:14.802] List of 5
[21:39:14.802] $ ...future.FUN :function (x)
[21:39:14.802] $ future.call.arguments : list()
[21:39:14.802] ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[21:39:14.802] $ ...future.elements_ii :List of 1
[21:39:14.802] ..$ : int 0
[21:39:14.802] $ ...future.seeds_ii : NULL
[21:39:14.802] $ ...future.globals.maxSize: NULL
[21:39:14.802] - attr(*, "where")=List of 5
[21:39:14.802] ..$ ...future.FUN :<environment: R_EmptyEnv>
[21:39:14.802] ..$ future.call.arguments :<environment: R_EmptyEnv>
[21:39:14.802] ..$ ...future.elements_ii :<environment: R_EmptyEnv>
[21:39:14.802] ..$ ...future.seeds_ii :<environment: R_EmptyEnv>
[21:39:14.802] ..$ ...future.globals.maxSize:<environment: R_EmptyEnv>
[21:39:14.802] - attr(*, "resolved")= logi FALSE
[21:39:14.802] - attr(*, "total_size")= num 4720
[21:39:14.802] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[21:39:14.802] - attr(*, "already-done")= logi TRUE
[21:39:14.833] - reassign environment for '...future.FUN'
[21:39:14.833] - copied '...future.FUN' to environment
[21:39:14.834] - copied 'future.call.arguments' to environment
[21:39:14.834] - copied '...future.elements_ii' to environment
[21:39:14.834] - copied '...future.seeds_ii' to environment
[21:39:14.835] - copied '...future.globals.maxSize' to environment
[21:39:14.835] assign_globals() ... done
[21:39:14.835] requestCore(): workers = 2
[21:39:14.858] MulticoreFuture started
[21:39:14.858] - Launch lazy future ... done
[21:39:14.859] run() for 'MulticoreFuture' ... done
[21:39:14.859] Created future:
[21:39:14.860] MulticoreFuture:
[21:39:14.860] Label: 'future_lapply-2'
[21:39:14.860] Expression:
[21:39:14.860] {
[21:39:14.860] do.call(function(...) {
[21:39:14.860] ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[21:39:14.860] if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[21:39:14.860] oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[21:39:14.860] on.exit(options(oopts), add = TRUE)
[21:39:14.860] }
[21:39:14.860] {
[21:39:14.860] lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[21:39:14.860] ...future.X_jj <- ...future.elements_ii[[jj]]
[21:39:14.860] ...future.FUN(...future.X_jj, ...)
[21:39:14.860] })
[21:39:14.860] }
[21:39:14.860] }, args = future.call.arguments)
[21:39:14.860] }
[21:39:14.860] Lazy evaluation: FALSE
[21:39:14.860] Asynchronous evaluation: TRUE
[21:39:14.860] Local evaluation: TRUE
[21:39:14.860] Environment: R_GlobalEnv
[21:39:14.860] Capture standard output: FALSE
[21:39:14.860] Capture condition classes: 'condition' (excluding 'nothing')
[21:39:14.860] Globals: 5 objects totaling 4.66 KiB (function '...future.FUN' of 4.61 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[21:39:14.860] Packages: <none>
[21:39:14.860] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[21:39:14.860] Resolved: FALSE
[21:39:14.860] Value: <not collected>
[21:39:14.860] Conditions captured: <none>
[21:39:14.860] Early signaling: FALSE
[21:39:14.860] Owner process: 72e8b611-9cdd-9e9c-b181-2821577df87f
[21:39:14.860] Class: 'MulticoreFuture', 'MultiprocessFuture', 'Future', 'environment'
[21:39:14.875] Chunk #2 of 2 ... DONE
[21:39:14.875] Launching 2 futures (chunks) ... DONE
[21:39:14.876] Resolving 2 futures (chunks) ...
[21:39:14.876] resolve() on list ...
[21:39:14.876] recursive: 0