Last updated on 2024-05-27 15:55:41 CEST.
| Package | ERROR | NOTE | OK |
|---|---|---|---|
| ACNE | 13 | ||
| aroma.affymetrix | 9 | 4 | |
| aroma.apd | 2 | 10 | |
| aroma.cn | 2 | 11 | |
| aroma.core | 13 | ||
| calmate | 1 | 12 | |
| dChipIO | 12 | ||
| doFuture | 12 | ||
| future | 13 | ||
| future.apply | 13 | ||
| future.batchtools | 12 | ||
| future.callr | 12 | ||
| future.mirai | 1 | 12 | |
| future.tests | 12 | ||
| globals | 13 | ||
| listenv | 13 | ||
| matrixStats | 13 | ||
| parallelly | 13 | ||
| port4me | 13 | ||
| profmem | 1 | 11 | |
| progressr | 12 | ||
| PSCBS | 13 | ||
| R.cache | 9 | 3 | |
| R.devices | 13 | ||
| R.filesets | 13 | ||
| R.huge | 13 | ||
| R.matlab | 9 | 3 | |
| R.methodsS3 | 12 | ||
| R.oo | 13 | ||
| R.rsp | 13 | ||
| R.utils | 12 | ||
| seguid | 13 | ||
| startup | 12 | ||
| TopDom | 9 | 3 |
Current CRAN status: OK: 13
Current CRAN status: NOTE: 9, OK: 4
Version: 3.2.2
Check: installed package size
Result: NOTE
installed size is 5.9Mb
sub-directories of 1Mb or more:
R 2.3Mb
help 1.2Mb
testScripts 1.3Mb
Flavors: r-devel-linux-x86_64-fedora-clang, r-devel-windows-x86_64, r-release-macos-arm64, r-release-macos-x86_64, r-release-windows-x86_64, r-oldrel-macos-arm64, r-oldrel-macos-x86_64, r-oldrel-windows-x86_64
Version: 3.2.2
Check: package dependencies
Result: NOTE
Packages suggested but not available for checking: 'oligo', 'pdInfoBuilder'
Flavor: r-devel-linux-x86_64-fedora-gcc
Version: 3.2.2
Check: Rd cross-references
Result: NOTE
Package unavailable to check Rd xrefs: ‘oligo’
Flavor: r-devel-linux-x86_64-fedora-gcc
Version: 3.2.2
Check: package dependencies
Result: NOTE
Package suggested but not available for checking: ‘AffymetrixDataTestFiles’
Flavors: r-release-macos-arm64, r-release-macos-x86_64
Version: 3.2.2
Check: package dependencies
Result: NOTE
Packages suggested but not available for checking:
'affxparser', 'oligo', 'oligoClasses', 'pdInfoBuilder',
'AffymetrixDataTestFiles'
Flavors: r-oldrel-macos-arm64, r-oldrel-macos-x86_64
Version: 3.2.2
Check: Rd cross-references
Result: NOTE
Packages unavailable to check Rd xrefs: ‘affxparser’, ‘oligo’, ‘oligoClasses’
Flavors: r-oldrel-macos-arm64, r-oldrel-macos-x86_64
Current CRAN status: NOTE: 2, OK: 10
Version: 0.7.0
Check: package dependencies
Result: NOTE
Package suggested but not available for checking: ‘affxparser’
Flavors: r-oldrel-macos-arm64, r-oldrel-macos-x86_64
Version: 0.7.0
Check: Rd cross-references
Result: NOTE
Package unavailable to check Rd xrefs: ‘affxparser’
Flavors: r-oldrel-macos-arm64, r-oldrel-macos-x86_64
Current CRAN status: NOTE: 2, OK: 11
Version: 1.7.1
Check: package dependencies
Result: NOTE
Package suggested but not available for checking: ‘GLAD’
Flavors: r-oldrel-macos-arm64, r-oldrel-macos-x86_64
Current CRAN status: NOTE: 13
Version: 3.3.1
Check: package dependencies
Result: NOTE
Packages suggested but not available for checking:
'sfit', 'expectile', 'HaarSeg', 'mpcbs'
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-devel-windows-x86_64, r-patched-linux-x86_64, r-release-linux-x86_64, r-release-macos-arm64, r-release-macos-x86_64, r-release-windows-x86_64, r-oldrel-windows-x86_64
Version: 3.3.1
Check: package dependencies
Result: NOTE
Packages suggested but not available for checking:
'GLAD', 'sfit', 'expectile', 'HaarSeg', 'mpcbs'
Flavors: r-oldrel-macos-arm64, r-oldrel-macos-x86_64
Version: 3.3.1
Check: Rd cross-references
Result: NOTE
Package unavailable to check Rd xrefs: ‘GLAD’
Flavors: r-oldrel-macos-arm64, r-oldrel-macos-x86_64
Current CRAN status: ERROR: 1, OK: 12
Version: 0.13.0
Check: package dependencies
Result: ERROR
Package required but not available: ‘aroma.core’
See section ‘The DESCRIPTION file’ in the ‘Writing R Extensions’
manual.
Flavor: r-oldrel-macos-arm64
Current CRAN status: OK: 12
Current CRAN status: OK: 12
Current CRAN status: OK: 13
Current CRAN status: OK: 13
Current CRAN status: OK: 12
Current CRAN status: OK: 12
Current CRAN status: ERROR: 1, OK: 12
Version: 0.2.1
Check: tests
Result: ERROR
Running 'demo.R' [2s]
Running 'dotdotdot.R' [2s]
Running 'future,labels.R' [2s]
Running 'future,lazy.R' [2s]
Running 'future.tests,mirai_cluster.R' [16s]
Running 'future.tests-mirai_multisession.R' [19s]
Running 'globals,formulas.R' [2s]
Running 'globals,manual.R' [2s]
Running 'globals,nested.R' [1s]
Running 'globals,subassignment.R' [2s]
Running 'globals,tricky.R' [2s]
Running 'mirai_cluster,worker-termination.R' [1s]
Running 'mirai_cluster.R' [2s]
Running 'nbrOfWorkers.R' [1s]
Running 'plan.R' [2s]
Running 'rng.R' [1s]
Running 'stdout.R' [2s]
Running 'zzz,future_lapply.R' [14s]
Running the tests in 'tests/dotdotdot.R' failed.
Complete output:
> source("incl/start.R")
Loading required package: future
[16:20:25.958] plan(): Setting new future strategy stack:
[16:20:25.960] List of future strategies:
[16:20:25.960] 1. mirai_multisession:
[16:20:25.960] - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
[16:20:25.960] - tweaked: FALSE
[16:20:25.960] - call: future::plan(future.mirai::mirai_multisession)
[16:20:25.981] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
[16:20:25.982] < mirai | $data >
[16:20:25.989] getGlobalsAndPackages() ...
[16:20:25.989] Not searching for globals
[16:20:25.990] - globals: [0] <none>
[16:20:25.990] getGlobalsAndPackages() ... DONE
[16:20:25.991] getGlobalsAndPackages() ...
[16:20:25.992]
[16:20:25.992] - globals: [0] <none>
[16:20:25.992] getGlobalsAndPackages() ... DONE
[16:20:26.482] Packages needed by the future expression (n = 0): <none>
[16:20:26.482] Packages needed by future strategies (n = 0): <none>
[16:20:26.484] {
[16:20:26.484] {
[16:20:26.484] {
[16:20:26.484] ...future.startTime <- base::Sys.time()
[16:20:26.484] {
[16:20:26.484] {
[16:20:26.484] {
[16:20:26.484] base::local({
[16:20:26.484] has_future <- base::requireNamespace("future",
[16:20:26.484] quietly = TRUE)
[16:20:26.484] if (has_future) {
[16:20:26.484] ns <- base::getNamespace("future")
[16:20:26.484] version <- ns[[".package"]][["version"]]
[16:20:26.484] if (is.null(version))
[16:20:26.484] version <- utils::packageVersion("future")
[16:20:26.484] }
[16:20:26.484] else {
[16:20:26.484] version <- NULL
[16:20:26.484] }
[16:20:26.484] if (!has_future || version < "1.8.0") {
[16:20:26.484] info <- base::c(r_version = base::gsub("R version ",
[16:20:26.484] "", base::R.version$version.string),
[16:20:26.484] platform = base::sprintf("%s (%s-bit)",
[16:20:26.484] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[16:20:26.484] os = base::paste(base::Sys.info()[base::c("sysname",
[16:20:26.484] "release", "version")], collapse = " "),
[16:20:26.484] hostname = base::Sys.info()[["nodename"]])
[16:20:26.484] info <- base::sprintf("%s: %s", base::names(info),
[16:20:26.484] info)
[16:20:26.484] info <- base::paste(info, collapse = "; ")
[16:20:26.484] if (!has_future) {
[16:20:26.484] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[16:20:26.484] info)
[16:20:26.484] }
[16:20:26.484] else {
[16:20:26.484] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[16:20:26.484] info, version)
[16:20:26.484] }
[16:20:26.484] base::stop(msg)
[16:20:26.484] }
[16:20:26.484] })
[16:20:26.484] }
[16:20:26.484] ...future.strategy.old <- future::plan("list")
[16:20:26.484] options(future.plan = NULL)
[16:20:26.484] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:26.484] future::plan("default", .cleanup = FALSE, .init = FALSE)
[16:20:26.484] }
[16:20:26.484] ...future.workdir <- getwd()
[16:20:26.484] }
[16:20:26.484] ...future.oldOptions <- base::as.list(base::.Options)
[16:20:26.484] ...future.oldEnvVars <- base::Sys.getenv()
[16:20:26.484] }
[16:20:26.484] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[16:20:26.484] future.globals.maxSize = NULL, future.globals.method = NULL,
[16:20:26.484] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[16:20:26.484] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[16:20:26.484] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[16:20:26.484] future.stdout.windows.reencode = NULL, width = 80L)
[16:20:26.484] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[16:20:26.484] base::names(...future.oldOptions))
[16:20:26.484] }
[16:20:26.484] if (FALSE) {
[16:20:26.484] }
[16:20:26.484] else {
[16:20:26.484] if (TRUE) {
[16:20:26.484] ...future.stdout <- base::rawConnection(base::raw(0L),
[16:20:26.484] open = "w")
[16:20:26.484] }
[16:20:26.484] else {
[16:20:26.484] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[16:20:26.484] windows = "NUL", "/dev/null"), open = "w")
[16:20:26.484] }
[16:20:26.484] base::sink(...future.stdout, type = "output", split = FALSE)
[16:20:26.484] base::on.exit(if (!base::is.null(...future.stdout)) {
[16:20:26.484] base::sink(type = "output", split = FALSE)
[16:20:26.484] base::close(...future.stdout)
[16:20:26.484] }, add = TRUE)
[16:20:26.484] }
[16:20:26.484] ...future.frame <- base::sys.nframe()
[16:20:26.484] ...future.conditions <- base::list()
[16:20:26.484] ...future.rng <- base::globalenv()$.Random.seed
[16:20:26.484] if (FALSE) {
[16:20:26.484] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[16:20:26.484] "...future.value", "...future.globalenv.names", ".Random.seed")
[16:20:26.484] }
[16:20:26.484] ...future.result <- base::tryCatch({
[16:20:26.484] base::withCallingHandlers({
[16:20:26.484] ...future.value <- base::withVisible(base::local(NA))
[16:20:26.484] future::FutureResult(value = ...future.value$value,
[16:20:26.484] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[16:20:26.484] ...future.rng), globalenv = if (FALSE)
[16:20:26.484] list(added = base::setdiff(base::names(base::.GlobalEnv),
[16:20:26.484] ...future.globalenv.names))
[16:20:26.484] else NULL, started = ...future.startTime, version = "1.8")
[16:20:26.484] }, condition = base::local({
[16:20:26.484] c <- base::c
[16:20:26.484] inherits <- base::inherits
[16:20:26.484] invokeRestart <- base::invokeRestart
[16:20:26.484] length <- base::length
[16:20:26.484] list <- base::list
[16:20:26.484] seq.int <- base::seq.int
[16:20:26.484] signalCondition <- base::signalCondition
[16:20:26.484] sys.calls <- base::sys.calls
[16:20:26.484] `[[` <- base::`[[`
[16:20:26.484] `+` <- base::`+`
[16:20:26.484] `<<-` <- base::`<<-`
[16:20:26.484] sysCalls <- function(calls = sys.calls(), from = 1L) {
[16:20:26.484] calls[seq.int(from = from + 12L, to = length(calls) -
[16:20:26.484] 3L)]
[16:20:26.484] }
[16:20:26.484] function(cond) {
[16:20:26.484] is_error <- inherits(cond, "error")
[16:20:26.484] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[16:20:26.484] NULL)
[16:20:26.484] if (is_error) {
[16:20:26.484] sessionInformation <- function() {
[16:20:26.484] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[16:20:26.484] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[16:20:26.484] search = base::search(), system = base::Sys.info())
[16:20:26.484] }
[16:20:26.484] ...future.conditions[[length(...future.conditions) +
[16:20:26.484] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[16:20:26.484] cond$call), session = sessionInformation(),
[16:20:26.484] timestamp = base::Sys.time(), signaled = 0L)
[16:20:26.484] signalCondition(cond)
[16:20:26.484] }
[16:20:26.484] else if (!ignore && TRUE && inherits(cond, "condition")) {
[16:20:26.484] signal <- FALSE && inherits(cond, character(0))
[16:20:26.484] ...future.conditions[[length(...future.conditions) +
[16:20:26.484] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[16:20:26.484] if (FALSE && !signal) {
[16:20:26.484] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:26.484] {
[16:20:26.484] inherits <- base::inherits
[16:20:26.484] invokeRestart <- base::invokeRestart
[16:20:26.484] is.null <- base::is.null
[16:20:26.484] muffled <- FALSE
[16:20:26.484] if (inherits(cond, "message")) {
[16:20:26.484] muffled <- grepl(pattern, "muffleMessage")
[16:20:26.484] if (muffled)
[16:20:26.484] invokeRestart("muffleMessage")
[16:20:26.484] }
[16:20:26.484] else if (inherits(cond, "warning")) {
[16:20:26.484] muffled <- grepl(pattern, "muffleWarning")
[16:20:26.484] if (muffled)
[16:20:26.484] invokeRestart("muffleWarning")
[16:20:26.484] }
[16:20:26.484] else if (inherits(cond, "condition")) {
[16:20:26.484] if (!is.null(pattern)) {
[16:20:26.484] computeRestarts <- base::computeRestarts
[16:20:26.484] grepl <- base::grepl
[16:20:26.484] restarts <- computeRestarts(cond)
[16:20:26.484] for (restart in restarts) {
[16:20:26.484] name <- restart$name
[16:20:26.484] if (is.null(name))
[16:20:26.484] next
[16:20:26.484] if (!grepl(pattern, name))
[16:20:26.484] next
[16:20:26.484] invokeRestart(restart)
[16:20:26.484] muffled <- TRUE
[16:20:26.484] break
[16:20:26.484] }
[16:20:26.484] }
[16:20:26.484] }
[16:20:26.484] invisible(muffled)
[16:20:26.484] }
[16:20:26.484] muffleCondition(cond, pattern = "^muffle")
[16:20:26.484] }
[16:20:26.484] }
[16:20:26.484] else {
[16:20:26.484] if (TRUE) {
[16:20:26.484] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:26.484] {
[16:20:26.484] inherits <- base::inherits
[16:20:26.484] invokeRestart <- base::invokeRestart
[16:20:26.484] is.null <- base::is.null
[16:20:26.484] muffled <- FALSE
[16:20:26.484] if (inherits(cond, "message")) {
[16:20:26.484] muffled <- grepl(pattern, "muffleMessage")
[16:20:26.484] if (muffled)
[16:20:26.484] invokeRestart("muffleMessage")
[16:20:26.484] }
[16:20:26.484] else if (inherits(cond, "warning")) {
[16:20:26.484] muffled <- grepl(pattern, "muffleWarning")
[16:20:26.484] if (muffled)
[16:20:26.484] invokeRestart("muffleWarning")
[16:20:26.484] }
[16:20:26.484] else if (inherits(cond, "condition")) {
[16:20:26.484] if (!is.null(pattern)) {
[16:20:26.484] computeRestarts <- base::computeRestarts
[16:20:26.484] grepl <- base::grepl
[16:20:26.484] restarts <- computeRestarts(cond)
[16:20:26.484] for (restart in restarts) {
[16:20:26.484] name <- restart$name
[16:20:26.484] if (is.null(name))
[16:20:26.484] next
[16:20:26.484] if (!grepl(pattern, name))
[16:20:26.484] next
[16:20:26.484] invokeRestart(restart)
[16:20:26.484] muffled <- TRUE
[16:20:26.484] break
[16:20:26.484] }
[16:20:26.484] }
[16:20:26.484] }
[16:20:26.484] invisible(muffled)
[16:20:26.484] }
[16:20:26.484] muffleCondition(cond, pattern = "^muffle")
[16:20:26.484] }
[16:20:26.484] }
[16:20:26.484] }
[16:20:26.484] }))
[16:20:26.484] }, error = function(ex) {
[16:20:26.484] base::structure(base::list(value = NULL, visible = NULL,
[16:20:26.484] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[16:20:26.484] ...future.rng), started = ...future.startTime,
[16:20:26.484] finished = Sys.time(), session_uuid = NA_character_,
[16:20:26.484] version = "1.8"), class = "FutureResult")
[16:20:26.484] }, finally = {
[16:20:26.484] if (!identical(...future.workdir, getwd()))
[16:20:26.484] setwd(...future.workdir)
[16:20:26.484] {
[16:20:26.484] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[16:20:26.484] ...future.oldOptions$nwarnings <- NULL
[16:20:26.484] }
[16:20:26.484] base::options(...future.oldOptions)
[16:20:26.484] if (.Platform$OS.type == "windows") {
[16:20:26.484] old_names <- names(...future.oldEnvVars)
[16:20:26.484] envs <- base::Sys.getenv()
[16:20:26.484] names <- names(envs)
[16:20:26.484] common <- intersect(names, old_names)
[16:20:26.484] added <- setdiff(names, old_names)
[16:20:26.484] removed <- setdiff(old_names, names)
[16:20:26.484] changed <- common[...future.oldEnvVars[common] !=
[16:20:26.484] envs[common]]
[16:20:26.484] NAMES <- toupper(changed)
[16:20:26.484] args <- list()
[16:20:26.484] for (kk in seq_along(NAMES)) {
[16:20:26.484] name <- changed[[kk]]
[16:20:26.484] NAME <- NAMES[[kk]]
[16:20:26.484] if (name != NAME && is.element(NAME, old_names))
[16:20:26.484] next
[16:20:26.484] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:26.484] }
[16:20:26.484] NAMES <- toupper(added)
[16:20:26.484] for (kk in seq_along(NAMES)) {
[16:20:26.484] name <- added[[kk]]
[16:20:26.484] NAME <- NAMES[[kk]]
[16:20:26.484] if (name != NAME && is.element(NAME, old_names))
[16:20:26.484] next
[16:20:26.484] args[[name]] <- ""
[16:20:26.484] }
[16:20:26.484] NAMES <- toupper(removed)
[16:20:26.484] for (kk in seq_along(NAMES)) {
[16:20:26.484] name <- removed[[kk]]
[16:20:26.484] NAME <- NAMES[[kk]]
[16:20:26.484] if (name != NAME && is.element(NAME, old_names))
[16:20:26.484] next
[16:20:26.484] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:26.484] }
[16:20:26.484] if (length(args) > 0)
[16:20:26.484] base::do.call(base::Sys.setenv, args = args)
[16:20:26.484] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[16:20:26.484] }
[16:20:26.484] else {
[16:20:26.484] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[16:20:26.484] }
[16:20:26.484] {
[16:20:26.484] if (base::length(...future.futureOptionsAdded) >
[16:20:26.484] 0L) {
[16:20:26.484] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[16:20:26.484] base::names(opts) <- ...future.futureOptionsAdded
[16:20:26.484] base::options(opts)
[16:20:26.484] }
[16:20:26.484] {
[16:20:26.484] NULL
[16:20:26.484] options(future.plan = NULL)
[16:20:26.484] if (is.na(NA_character_))
[16:20:26.484] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:26.484] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[16:20:26.484] future::plan(...future.strategy.old, .cleanup = FALSE,
[16:20:26.484] .init = FALSE)
[16:20:26.484] }
[16:20:26.484] }
[16:20:26.484] }
[16:20:26.484] })
[16:20:26.484] if (TRUE) {
[16:20:26.484] base::sink(type = "output", split = FALSE)
[16:20:26.484] if (TRUE) {
[16:20:26.484] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[16:20:26.484] }
[16:20:26.484] else {
[16:20:26.484] ...future.result["stdout"] <- base::list(NULL)
[16:20:26.484] }
[16:20:26.484] base::close(...future.stdout)
[16:20:26.484] ...future.stdout <- NULL
[16:20:26.484] }
[16:20:26.484] ...future.result$conditions <- ...future.conditions
[16:20:26.484] ...future.result$finished <- base::Sys.time()
[16:20:26.484] ...future.result
[16:20:26.484] }
[16:20:26.645] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ... DONE
[16:20:26.646] plan(): nbrOfWorkers() = 2
> library("listenv")
>
> message("*** Global argument '...' in futures ...")
*** Global argument '...' in futures ...
>
> sum_fcns <- list()
>
> sum_fcns$A <- function(x, ...) {
+ message("Arguments '...' exists: ", exists("...", inherits = TRUE))
+ y %<-% { sum(x, ...) }
+ y
+ }
>
>
> sum_fcns$B <- function(x, ...) {
+ sumt <- function(x) {
+ message("Arguments '...' exists: ", exists("...", inherits = TRUE))
+ y %<-% { sum(x, ...) }
+ y
+ }
+ sumt(x)
+ }
>
> sum_fcns$C <- function(x, y) {
+ message("Arguments '...' exists: ", exists("...", inherits = TRUE))
+ y %<-% { sum(x, y) }
+ y
+ }
>
> sum_fcns$D <- function(x, y) {
+ message("Arguments '...' exists: ", exists("...", inherits = TRUE))
+ y %<-% { sum(x, y, ...) }
+ y
+ }
>
>
> for (strategy in c("mirai_cluster", "mirai_multisession")) {
+ plan(strategy, substitute = FALSE)
+
+ for (name in names(sum_fcns)) {
+ mprintf("** Sum function '%s' with plan('%s') ...", name, strategy)
+ sum_fcn <- sum_fcns[[name]]
+ print(sum_fcn)
+ y <- tryCatch({
+ sum_fcn(1:2, 3)
+ }, error = identity)
+ print(y)
+ if (name %in% c("D")) {
+ stopifnot(inherits(y, "error"))
+ } else {
+ stopifnot(y == 6)
+ }
+ }
+ }
[16:20:26.674] plan(): Setting new future strategy stack:
[16:20:26.674] List of future strategies:
[16:20:26.674] 1. mirai_cluster:
[16:20:26.674] - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = "<NULL>")
[16:20:26.674] - tweaked: FALSE
[16:20:26.674] - call: plan(strategy, substitute = FALSE)
[16:20:26.698] plan(): plan_init() of 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
[16:20:26.698] < mirai | $data >
[16:20:26.699] getGlobalsAndPackages() ...
[16:20:26.699] Not searching for globals
[16:20:26.699] - globals: [0] <none>
[16:20:26.699] getGlobalsAndPackages() ... DONE
[16:20:26.700] getGlobalsAndPackages() ...
[16:20:26.700]
[16:20:26.700] - globals: [0] <none>
[16:20:26.700] getGlobalsAndPackages() ... DONE
[16:20:26.701] Packages needed by the future expression (n = 0): <none>
[16:20:26.701] Packages needed by future strategies (n = 0): <none>
[16:20:26.702] {
[16:20:26.702] {
[16:20:26.702] {
[16:20:26.702] ...future.startTime <- base::Sys.time()
[16:20:26.702] {
[16:20:26.702] {
[16:20:26.702] {
[16:20:26.702] base::local({
[16:20:26.702] has_future <- base::requireNamespace("future",
[16:20:26.702] quietly = TRUE)
[16:20:26.702] if (has_future) {
[16:20:26.702] ns <- base::getNamespace("future")
[16:20:26.702] version <- ns[[".package"]][["version"]]
[16:20:26.702] if (is.null(version))
[16:20:26.702] version <- utils::packageVersion("future")
[16:20:26.702] }
[16:20:26.702] else {
[16:20:26.702] version <- NULL
[16:20:26.702] }
[16:20:26.702] if (!has_future || version < "1.8.0") {
[16:20:26.702] info <- base::c(r_version = base::gsub("R version ",
[16:20:26.702] "", base::R.version$version.string),
[16:20:26.702] platform = base::sprintf("%s (%s-bit)",
[16:20:26.702] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[16:20:26.702] os = base::paste(base::Sys.info()[base::c("sysname",
[16:20:26.702] "release", "version")], collapse = " "),
[16:20:26.702] hostname = base::Sys.info()[["nodename"]])
[16:20:26.702] info <- base::sprintf("%s: %s", base::names(info),
[16:20:26.702] info)
[16:20:26.702] info <- base::paste(info, collapse = "; ")
[16:20:26.702] if (!has_future) {
[16:20:26.702] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[16:20:26.702] info)
[16:20:26.702] }
[16:20:26.702] else {
[16:20:26.702] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[16:20:26.702] info, version)
[16:20:26.702] }
[16:20:26.702] base::stop(msg)
[16:20:26.702] }
[16:20:26.702] })
[16:20:26.702] }
[16:20:26.702] ...future.strategy.old <- future::plan("list")
[16:20:26.702] options(future.plan = NULL)
[16:20:26.702] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:26.702] future::plan("default", .cleanup = FALSE, .init = FALSE)
[16:20:26.702] }
[16:20:26.702] ...future.workdir <- getwd()
[16:20:26.702] }
[16:20:26.702] ...future.oldOptions <- base::as.list(base::.Options)
[16:20:26.702] ...future.oldEnvVars <- base::Sys.getenv()
[16:20:26.702] }
[16:20:26.702] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[16:20:26.702] future.globals.maxSize = NULL, future.globals.method = NULL,
[16:20:26.702] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[16:20:26.702] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[16:20:26.702] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[16:20:26.702] future.stdout.windows.reencode = NULL, width = 80L)
[16:20:26.702] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[16:20:26.702] base::names(...future.oldOptions))
[16:20:26.702] }
[16:20:26.702] if (FALSE) {
[16:20:26.702] }
[16:20:26.702] else {
[16:20:26.702] if (TRUE) {
[16:20:26.702] ...future.stdout <- base::rawConnection(base::raw(0L),
[16:20:26.702] open = "w")
[16:20:26.702] }
[16:20:26.702] else {
[16:20:26.702] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[16:20:26.702] windows = "NUL", "/dev/null"), open = "w")
[16:20:26.702] }
[16:20:26.702] base::sink(...future.stdout, type = "output", split = FALSE)
[16:20:26.702] base::on.exit(if (!base::is.null(...future.stdout)) {
[16:20:26.702] base::sink(type = "output", split = FALSE)
[16:20:26.702] base::close(...future.stdout)
[16:20:26.702] }, add = TRUE)
[16:20:26.702] }
[16:20:26.702] ...future.frame <- base::sys.nframe()
[16:20:26.702] ...future.conditions <- base::list()
[16:20:26.702] ...future.rng <- base::globalenv()$.Random.seed
[16:20:26.702] if (FALSE) {
[16:20:26.702] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[16:20:26.702] "...future.value", "...future.globalenv.names", ".Random.seed")
[16:20:26.702] }
[16:20:26.702] ...future.result <- base::tryCatch({
[16:20:26.702] base::withCallingHandlers({
[16:20:26.702] ...future.value <- base::withVisible(base::local(NA))
[16:20:26.702] future::FutureResult(value = ...future.value$value,
[16:20:26.702] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[16:20:26.702] ...future.rng), globalenv = if (FALSE)
[16:20:26.702] list(added = base::setdiff(base::names(base::.GlobalEnv),
[16:20:26.702] ...future.globalenv.names))
[16:20:26.702] else NULL, started = ...future.startTime, version = "1.8")
[16:20:26.702] }, condition = base::local({
[16:20:26.702] c <- base::c
[16:20:26.702] inherits <- base::inherits
[16:20:26.702] invokeRestart <- base::invokeRestart
[16:20:26.702] length <- base::length
[16:20:26.702] list <- base::list
[16:20:26.702] seq.int <- base::seq.int
[16:20:26.702] signalCondition <- base::signalCondition
[16:20:26.702] sys.calls <- base::sys.calls
[16:20:26.702] `[[` <- base::`[[`
[16:20:26.702] `+` <- base::`+`
[16:20:26.702] `<<-` <- base::`<<-`
[16:20:26.702] sysCalls <- function(calls = sys.calls(), from = 1L) {
[16:20:26.702] calls[seq.int(from = from + 12L, to = length(calls) -
[16:20:26.702] 3L)]
[16:20:26.702] }
[16:20:26.702] function(cond) {
[16:20:26.702] is_error <- inherits(cond, "error")
[16:20:26.702] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[16:20:26.702] NULL)
[16:20:26.702] if (is_error) {
[16:20:26.702] sessionInformation <- function() {
[16:20:26.702] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[16:20:26.702] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[16:20:26.702] search = base::search(), system = base::Sys.info())
[16:20:26.702] }
[16:20:26.702] ...future.conditions[[length(...future.conditions) +
[16:20:26.702] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[16:20:26.702] cond$call), session = sessionInformation(),
[16:20:26.702] timestamp = base::Sys.time(), signaled = 0L)
[16:20:26.702] signalCondition(cond)
[16:20:26.702] }
[16:20:26.702] else if (!ignore && TRUE && inherits(cond, "condition")) {
[16:20:26.702] signal <- FALSE && inherits(cond, character(0))
[16:20:26.702] ...future.conditions[[length(...future.conditions) +
[16:20:26.702] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[16:20:26.702] if (FALSE && !signal) {
[16:20:26.702] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:26.702] {
[16:20:26.702] inherits <- base::inherits
[16:20:26.702] invokeRestart <- base::invokeRestart
[16:20:26.702] is.null <- base::is.null
[16:20:26.702] muffled <- FALSE
[16:20:26.702] if (inherits(cond, "message")) {
[16:20:26.702] muffled <- grepl(pattern, "muffleMessage")
[16:20:26.702] if (muffled)
[16:20:26.702] invokeRestart("muffleMessage")
[16:20:26.702] }
[16:20:26.702] else if (inherits(cond, "warning")) {
[16:20:26.702] muffled <- grepl(pattern, "muffleWarning")
[16:20:26.702] if (muffled)
[16:20:26.702] invokeRestart("muffleWarning")
[16:20:26.702] }
[16:20:26.702] else if (inherits(cond, "condition")) {
[16:20:26.702] if (!is.null(pattern)) {
[16:20:26.702] computeRestarts <- base::computeRestarts
[16:20:26.702] grepl <- base::grepl
[16:20:26.702] restarts <- computeRestarts(cond)
[16:20:26.702] for (restart in restarts) {
[16:20:26.702] name <- restart$name
[16:20:26.702] if (is.null(name))
[16:20:26.702] next
[16:20:26.702] if (!grepl(pattern, name))
[16:20:26.702] next
[16:20:26.702] invokeRestart(restart)
[16:20:26.702] muffled <- TRUE
[16:20:26.702] break
[16:20:26.702] }
[16:20:26.702] }
[16:20:26.702] }
[16:20:26.702] invisible(muffled)
[16:20:26.702] }
[16:20:26.702] muffleCondition(cond, pattern = "^muffle")
[16:20:26.702] }
[16:20:26.702] }
[16:20:26.702] else {
[16:20:26.702] if (TRUE) {
[16:20:26.702] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:26.702] {
[16:20:26.702] inherits <- base::inherits
[16:20:26.702] invokeRestart <- base::invokeRestart
[16:20:26.702] is.null <- base::is.null
[16:20:26.702] muffled <- FALSE
[16:20:26.702] if (inherits(cond, "message")) {
[16:20:26.702] muffled <- grepl(pattern, "muffleMessage")
[16:20:26.702] if (muffled)
[16:20:26.702] invokeRestart("muffleMessage")
[16:20:26.702] }
[16:20:26.702] else if (inherits(cond, "warning")) {
[16:20:26.702] muffled <- grepl(pattern, "muffleWarning")
[16:20:26.702] if (muffled)
[16:20:26.702] invokeRestart("muffleWarning")
[16:20:26.702] }
[16:20:26.702] else if (inherits(cond, "condition")) {
[16:20:26.702] if (!is.null(pattern)) {
[16:20:26.702] computeRestarts <- base::computeRestarts
[16:20:26.702] grepl <- base::grepl
[16:20:26.702] restarts <- computeRestarts(cond)
[16:20:26.702] for (restart in restarts) {
[16:20:26.702] name <- restart$name
[16:20:26.702] if (is.null(name))
[16:20:26.702] next
[16:20:26.702] if (!grepl(pattern, name))
[16:20:26.702] next
[16:20:26.702] invokeRestart(restart)
[16:20:26.702] muffled <- TRUE
[16:20:26.702] break
[16:20:26.702] }
[16:20:26.702] }
[16:20:26.702] }
[16:20:26.702] invisible(muffled)
[16:20:26.702] }
[16:20:26.702] muffleCondition(cond, pattern = "^muffle")
[16:20:26.702] }
[16:20:26.702] }
[16:20:26.702] }
[16:20:26.702] }))
[16:20:26.702] }, error = function(ex) {
[16:20:26.702] base::structure(base::list(value = NULL, visible = NULL,
[16:20:26.702] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[16:20:26.702] ...future.rng), started = ...future.startTime,
[16:20:26.702] finished = Sys.time(), session_uuid = NA_character_,
[16:20:26.702] version = "1.8"), class = "FutureResult")
[16:20:26.702] }, finally = {
[16:20:26.702] if (!identical(...future.workdir, getwd()))
[16:20:26.702] setwd(...future.workdir)
[16:20:26.702] {
[16:20:26.702] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[16:20:26.702] ...future.oldOptions$nwarnings <- NULL
[16:20:26.702] }
[16:20:26.702] base::options(...future.oldOptions)
[16:20:26.702] if (.Platform$OS.type == "windows") {
[16:20:26.702] old_names <- names(...future.oldEnvVars)
[16:20:26.702] envs <- base::Sys.getenv()
[16:20:26.702] names <- names(envs)
[16:20:26.702] common <- intersect(names, old_names)
[16:20:26.702] added <- setdiff(names, old_names)
[16:20:26.702] removed <- setdiff(old_names, names)
[16:20:26.702] changed <- common[...future.oldEnvVars[common] !=
[16:20:26.702] envs[common]]
[16:20:26.702] NAMES <- toupper(changed)
[16:20:26.702] args <- list()
[16:20:26.702] for (kk in seq_along(NAMES)) {
[16:20:26.702] name <- changed[[kk]]
[16:20:26.702] NAME <- NAMES[[kk]]
[16:20:26.702] if (name != NAME && is.element(NAME, old_names))
[16:20:26.702] next
[16:20:26.702] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:26.702] }
[16:20:26.702] NAMES <- toupper(added)
[16:20:26.702] for (kk in seq_along(NAMES)) {
[16:20:26.702] name <- added[[kk]]
[16:20:26.702] NAME <- NAMES[[kk]]
[16:20:26.702] if (name != NAME && is.element(NAME, old_names))
[16:20:26.702] next
[16:20:26.702] args[[name]] <- ""
[16:20:26.702] }
[16:20:26.702] NAMES <- toupper(removed)
[16:20:26.702] for (kk in seq_along(NAMES)) {
[16:20:26.702] name <- removed[[kk]]
[16:20:26.702] NAME <- NAMES[[kk]]
[16:20:26.702] if (name != NAME && is.element(NAME, old_names))
[16:20:26.702] next
[16:20:26.702] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:26.702] }
[16:20:26.702] if (length(args) > 0)
[16:20:26.702] base::do.call(base::Sys.setenv, args = args)
[16:20:26.702] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[16:20:26.702] }
[16:20:26.702] else {
[16:20:26.702] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[16:20:26.702] }
[16:20:26.702] {
[16:20:26.702] if (base::length(...future.futureOptionsAdded) >
[16:20:26.702] 0L) {
[16:20:26.702] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[16:20:26.702] base::names(opts) <- ...future.futureOptionsAdded
[16:20:26.702] base::options(opts)
[16:20:26.702] }
[16:20:26.702] {
[16:20:26.702] NULL
[16:20:26.702] options(future.plan = NULL)
[16:20:26.702] if (is.na(NA_character_))
[16:20:26.702] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:26.702] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[16:20:26.702] future::plan(...future.strategy.old, .cleanup = FALSE,
[16:20:26.702] .init = FALSE)
[16:20:26.702] }
[16:20:26.702] }
[16:20:26.702] }
[16:20:26.702] })
[16:20:26.702] if (TRUE) {
[16:20:26.702] base::sink(type = "output", split = FALSE)
[16:20:26.702] if (TRUE) {
[16:20:26.702] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[16:20:26.702] }
[16:20:26.702] else {
[16:20:26.702] ...future.result["stdout"] <- base::list(NULL)
[16:20:26.702] }
[16:20:26.702] base::close(...future.stdout)
[16:20:26.702] ...future.stdout <- NULL
[16:20:26.702] }
[16:20:26.702] ...future.result$conditions <- ...future.conditions
[16:20:26.702] ...future.result$finished <- base::Sys.time()
[16:20:26.702] ...future.result
[16:20:26.702] }
[16:20:26.879] plan(): plan_init() of 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ... DONE
[16:20:26.879] plan(): nbrOfWorkers() = 2
[16:20:26.880] ** Sum function 'A' with plan('mirai_cluster') ...function (x, ...)
{
message("Arguments '...' exists: ", exists("...", inherits = TRUE))
y %<-% {
sum(x, ...)
}
y
}
Arguments '...' exists: TRUE
[16:20:26.882] getGlobalsAndPackages() ...
[16:20:26.882] Searching for globals...
[16:20:26.896] - globals found: [4] '{', 'sum', 'x', '...'
[16:20:26.896] Searching for globals ... DONE
[16:20:26.896] Resolving globals: FALSE
[16:20:26.897] Tweak future expression to call with '...' arguments ...
[16:20:26.897] {
[16:20:26.897] do.call(function(...) {
[16:20:26.897] sum(x, ...)
[16:20:26.897] }, args = future.call.arguments)
[16:20:26.897] }
[16:20:26.897] Tweak future expression to call with '...' arguments ... DONE
[16:20:26.900] The total size of the 2 globals is 112 bytes (112 bytes)
[16:20:26.901] The total size of the 2 globals exported for future expression ('{; sum(x, ...); }') is 112 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (56 bytes of class 'numeric') and 'future.call.arguments' (56 bytes of class 'list')
[16:20:26.901] - globals: [2] 'x', 'future.call.arguments'
[16:20:26.902]
[16:20:26.902] getGlobalsAndPackages() ... DONE
[16:20:26.903] run() for 'Future' ...
[16:20:26.903] - state: 'created'
[16:20:26.903] - Future backend: 'FutureStrategy', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function'
[16:20:26.904] - Future class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[16:20:26.904] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ...
[16:20:26.905] - Field: 'label'
[16:20:26.905] - Field: 'local'
[16:20:26.905] - Field: 'owner'
[16:20:26.906] - Field: 'envir'
[16:20:26.906] - Field: 'packages'
[16:20:26.906] - Field: 'gc'
[16:20:26.907] - Field: 'conditions'
[16:20:26.907] - Field: 'expr'
[16:20:26.907] - Field: 'uuid'
[16:20:26.908] - Field: 'seed'
[16:20:26.908] - Field: 'version'
[16:20:26.908] - Field: 'result'
[16:20:26.908] - Field: 'asynchronous'
[16:20:26.909] - Field: 'calls'
[16:20:26.909] - Field: 'globals'
[16:20:26.909] - Field: 'stdout'
[16:20:26.910] - Field: 'earlySignal'
[16:20:26.910] - Field: 'lazy'
[16:20:26.910] - Field: 'state'
[16:20:26.910] - Field: '.cluster'
[16:20:26.911] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ... done
[16:20:26.911] - Launch lazy future ...
[16:20:26.911] Packages needed by the future expression (n = 0): <none>
[16:20:26.912] Packages needed by future strategies (n = 0): <none>
[16:20:26.913] {
[16:20:26.913] {
[16:20:26.913] {
[16:20:26.913] ...future.startTime <- base::Sys.time()
[16:20:26.913] {
[16:20:26.913] {
[16:20:26.913] {
[16:20:26.913] base::local({
[16:20:26.913] has_future <- base::requireNamespace("future",
[16:20:26.913] quietly = TRUE)
[16:20:26.913] if (has_future) {
[16:20:26.913] ns <- base::getNamespace("future")
[16:20:26.913] version <- ns[[".package"]][["version"]]
[16:20:26.913] if (is.null(version))
[16:20:26.913] version <- utils::packageVersion("future")
[16:20:26.913] }
[16:20:26.913] else {
[16:20:26.913] version <- NULL
[16:20:26.913] }
[16:20:26.913] if (!has_future || version < "1.8.0") {
[16:20:26.913] info <- base::c(r_version = base::gsub("R version ",
[16:20:26.913] "", base::R.version$version.string),
[16:20:26.913] platform = base::sprintf("%s (%s-bit)",
[16:20:26.913] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[16:20:26.913] os = base::paste(base::Sys.info()[base::c("sysname",
[16:20:26.913] "release", "version")], collapse = " "),
[16:20:26.913] hostname = base::Sys.info()[["nodename"]])
[16:20:26.913] info <- base::sprintf("%s: %s", base::names(info),
[16:20:26.913] info)
[16:20:26.913] info <- base::paste(info, collapse = "; ")
[16:20:26.913] if (!has_future) {
[16:20:26.913] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[16:20:26.913] info)
[16:20:26.913] }
[16:20:26.913] else {
[16:20:26.913] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[16:20:26.913] info, version)
[16:20:26.913] }
[16:20:26.913] base::stop(msg)
[16:20:26.913] }
[16:20:26.913] })
[16:20:26.913] }
[16:20:26.913] ...future.strategy.old <- future::plan("list")
[16:20:26.913] options(future.plan = NULL)
[16:20:26.913] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:26.913] future::plan("default", .cleanup = FALSE, .init = FALSE)
[16:20:26.913] }
[16:20:26.913] ...future.workdir <- getwd()
[16:20:26.913] }
[16:20:26.913] ...future.oldOptions <- base::as.list(base::.Options)
[16:20:26.913] ...future.oldEnvVars <- base::Sys.getenv()
[16:20:26.913] }
[16:20:26.913] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[16:20:26.913] future.globals.maxSize = NULL, future.globals.method = NULL,
[16:20:26.913] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[16:20:26.913] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[16:20:26.913] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[16:20:26.913] future.stdout.windows.reencode = NULL, width = 80L)
[16:20:26.913] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[16:20:26.913] base::names(...future.oldOptions))
[16:20:26.913] }
[16:20:26.913] if (FALSE) {
[16:20:26.913] }
[16:20:26.913] else {
[16:20:26.913] if (TRUE) {
[16:20:26.913] ...future.stdout <- base::rawConnection(base::raw(0L),
[16:20:26.913] open = "w")
[16:20:26.913] }
[16:20:26.913] else {
[16:20:26.913] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[16:20:26.913] windows = "NUL", "/dev/null"), open = "w")
[16:20:26.913] }
[16:20:26.913] base::sink(...future.stdout, type = "output", split = FALSE)
[16:20:26.913] base::on.exit(if (!base::is.null(...future.stdout)) {
[16:20:26.913] base::sink(type = "output", split = FALSE)
[16:20:26.913] base::close(...future.stdout)
[16:20:26.913] }, add = TRUE)
[16:20:26.913] }
[16:20:26.913] ...future.frame <- base::sys.nframe()
[16:20:26.913] ...future.conditions <- base::list()
[16:20:26.913] ...future.rng <- base::globalenv()$.Random.seed
[16:20:26.913] if (FALSE) {
[16:20:26.913] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[16:20:26.913] "...future.value", "...future.globalenv.names", ".Random.seed")
[16:20:26.913] }
[16:20:26.913] ...future.result <- base::tryCatch({
[16:20:26.913] base::withCallingHandlers({
[16:20:26.913] ...future.value <- base::withVisible(base::local({
[16:20:26.913] do.call(function(...) {
[16:20:26.913] sum(x, ...)
[16:20:26.913] }, args = future.call.arguments)
[16:20:26.913] }))
[16:20:26.913] future::FutureResult(value = ...future.value$value,
[16:20:26.913] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[16:20:26.913] ...future.rng), globalenv = if (FALSE)
[16:20:26.913] list(added = base::setdiff(base::names(base::.GlobalEnv),
[16:20:26.913] ...future.globalenv.names))
[16:20:26.913] else NULL, started = ...future.startTime, version = "1.8")
[16:20:26.913] }, condition = base::local({
[16:20:26.913] c <- base::c
[16:20:26.913] inherits <- base::inherits
[16:20:26.913] invokeRestart <- base::invokeRestart
[16:20:26.913] length <- base::length
[16:20:26.913] list <- base::list
[16:20:26.913] seq.int <- base::seq.int
[16:20:26.913] signalCondition <- base::signalCondition
[16:20:26.913] sys.calls <- base::sys.calls
[16:20:26.913] `[[` <- base::`[[`
[16:20:26.913] `+` <- base::`+`
[16:20:26.913] `<<-` <- base::`<<-`
[16:20:26.913] sysCalls <- function(calls = sys.calls(), from = 1L) {
[16:20:26.913] calls[seq.int(from = from + 12L, to = length(calls) -
[16:20:26.913] 3L)]
[16:20:26.913] }
[16:20:26.913] function(cond) {
[16:20:26.913] is_error <- inherits(cond, "error")
[16:20:26.913] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[16:20:26.913] NULL)
[16:20:26.913] if (is_error) {
[16:20:26.913] sessionInformation <- function() {
[16:20:26.913] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[16:20:26.913] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[16:20:26.913] search = base::search(), system = base::Sys.info())
[16:20:26.913] }
[16:20:26.913] ...future.conditions[[length(...future.conditions) +
[16:20:26.913] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[16:20:26.913] cond$call), session = sessionInformation(),
[16:20:26.913] timestamp = base::Sys.time(), signaled = 0L)
[16:20:26.913] signalCondition(cond)
[16:20:26.913] }
[16:20:26.913] else if (!ignore && TRUE && inherits(cond, "condition")) {
[16:20:26.913] signal <- FALSE && inherits(cond, character(0))
[16:20:26.913] ...future.conditions[[length(...future.conditions) +
[16:20:26.913] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[16:20:26.913] if (FALSE && !signal) {
[16:20:26.913] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:26.913] {
[16:20:26.913] inherits <- base::inherits
[16:20:26.913] invokeRestart <- base::invokeRestart
[16:20:26.913] is.null <- base::is.null
[16:20:26.913] muffled <- FALSE
[16:20:26.913] if (inherits(cond, "message")) {
[16:20:26.913] muffled <- grepl(pattern, "muffleMessage")
[16:20:26.913] if (muffled)
[16:20:26.913] invokeRestart("muffleMessage")
[16:20:26.913] }
[16:20:26.913] else if (inherits(cond, "warning")) {
[16:20:26.913] muffled <- grepl(pattern, "muffleWarning")
[16:20:26.913] if (muffled)
[16:20:26.913] invokeRestart("muffleWarning")
[16:20:26.913] }
[16:20:26.913] else if (inherits(cond, "condition")) {
[16:20:26.913] if (!is.null(pattern)) {
[16:20:26.913] computeRestarts <- base::computeRestarts
[16:20:26.913] grepl <- base::grepl
[16:20:26.913] restarts <- computeRestarts(cond)
[16:20:26.913] for (restart in restarts) {
[16:20:26.913] name <- restart$name
[16:20:26.913] if (is.null(name))
[16:20:26.913] next
[16:20:26.913] if (!grepl(pattern, name))
[16:20:26.913] next
[16:20:26.913] invokeRestart(restart)
[16:20:26.913] muffled <- TRUE
[16:20:26.913] break
[16:20:26.913] }
[16:20:26.913] }
[16:20:26.913] }
[16:20:26.913] invisible(muffled)
[16:20:26.913] }
[16:20:26.913] muffleCondition(cond, pattern = "^muffle")
[16:20:26.913] }
[16:20:26.913] }
[16:20:26.913] else {
[16:20:26.913] if (TRUE) {
[16:20:26.913] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:26.913] {
[16:20:26.913] inherits <- base::inherits
[16:20:26.913] invokeRestart <- base::invokeRestart
[16:20:26.913] is.null <- base::is.null
[16:20:26.913] muffled <- FALSE
[16:20:26.913] if (inherits(cond, "message")) {
[16:20:26.913] muffled <- grepl(pattern, "muffleMessage")
[16:20:26.913] if (muffled)
[16:20:26.913] invokeRestart("muffleMessage")
[16:20:26.913] }
[16:20:26.913] else if (inherits(cond, "warning")) {
[16:20:26.913] muffled <- grepl(pattern, "muffleWarning")
[16:20:26.913] if (muffled)
[16:20:26.913] invokeRestart("muffleWarning")
[16:20:26.913] }
[16:20:26.913] else if (inherits(cond, "condition")) {
[16:20:26.913] if (!is.null(pattern)) {
[16:20:26.913] computeRestarts <- base::computeRestarts
[16:20:26.913] grepl <- base::grepl
[16:20:26.913] restarts <- computeRestarts(cond)
[16:20:26.913] for (restart in restarts) {
[16:20:26.913] name <- restart$name
[16:20:26.913] if (is.null(name))
[16:20:26.913] next
[16:20:26.913] if (!grepl(pattern, name))
[16:20:26.913] next
[16:20:26.913] invokeRestart(restart)
[16:20:26.913] muffled <- TRUE
[16:20:26.913] break
[16:20:26.913] }
[16:20:26.913] }
[16:20:26.913] }
[16:20:26.913] invisible(muffled)
[16:20:26.913] }
[16:20:26.913] muffleCondition(cond, pattern = "^muffle")
[16:20:26.913] }
[16:20:26.913] }
[16:20:26.913] }
[16:20:26.913] }))
[16:20:26.913] }, error = function(ex) {
[16:20:26.913] base::structure(base::list(value = NULL, visible = NULL,
[16:20:26.913] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[16:20:26.913] ...future.rng), started = ...future.startTime,
[16:20:26.913] finished = Sys.time(), session_uuid = NA_character_,
[16:20:26.913] version = "1.8"), class = "FutureResult")
[16:20:26.913] }, finally = {
[16:20:26.913] if (!identical(...future.workdir, getwd()))
[16:20:26.913] setwd(...future.workdir)
[16:20:26.913] {
[16:20:26.913] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[16:20:26.913] ...future.oldOptions$nwarnings <- NULL
[16:20:26.913] }
[16:20:26.913] base::options(...future.oldOptions)
[16:20:26.913] if (.Platform$OS.type == "windows") {
[16:20:26.913] old_names <- names(...future.oldEnvVars)
[16:20:26.913] envs <- base::Sys.getenv()
[16:20:26.913] names <- names(envs)
[16:20:26.913] common <- intersect(names, old_names)
[16:20:26.913] added <- setdiff(names, old_names)
[16:20:26.913] removed <- setdiff(old_names, names)
[16:20:26.913] changed <- common[...future.oldEnvVars[common] !=
[16:20:26.913] envs[common]]
[16:20:26.913] NAMES <- toupper(changed)
[16:20:26.913] args <- list()
[16:20:26.913] for (kk in seq_along(NAMES)) {
[16:20:26.913] name <- changed[[kk]]
[16:20:26.913] NAME <- NAMES[[kk]]
[16:20:26.913] if (name != NAME && is.element(NAME, old_names))
[16:20:26.913] next
[16:20:26.913] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:26.913] }
[16:20:26.913] NAMES <- toupper(added)
[16:20:26.913] for (kk in seq_along(NAMES)) {
[16:20:26.913] name <- added[[kk]]
[16:20:26.913] NAME <- NAMES[[kk]]
[16:20:26.913] if (name != NAME && is.element(NAME, old_names))
[16:20:26.913] next
[16:20:26.913] args[[name]] <- ""
[16:20:26.913] }
[16:20:26.913] NAMES <- toupper(removed)
[16:20:26.913] for (kk in seq_along(NAMES)) {
[16:20:26.913] name <- removed[[kk]]
[16:20:26.913] NAME <- NAMES[[kk]]
[16:20:26.913] if (name != NAME && is.element(NAME, old_names))
[16:20:26.913] next
[16:20:26.913] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:26.913] }
[16:20:26.913] if (length(args) > 0)
[16:20:26.913] base::do.call(base::Sys.setenv, args = args)
[16:20:26.913] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[16:20:26.913] }
[16:20:26.913] else {
[16:20:26.913] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[16:20:26.913] }
[16:20:26.913] {
[16:20:26.913] if (base::length(...future.futureOptionsAdded) >
[16:20:26.913] 0L) {
[16:20:26.913] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[16:20:26.913] base::names(opts) <- ...future.futureOptionsAdded
[16:20:26.913] base::options(opts)
[16:20:26.913] }
[16:20:26.913] {
[16:20:26.913] NULL
[16:20:26.913] options(future.plan = NULL)
[16:20:26.913] if (is.na(NA_character_))
[16:20:26.913] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:26.913] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[16:20:26.913] future::plan(...future.strategy.old, .cleanup = FALSE,
[16:20:26.913] .init = FALSE)
[16:20:26.913] }
[16:20:26.913] }
[16:20:26.913] }
[16:20:26.913] })
[16:20:26.913] if (TRUE) {
[16:20:26.913] base::sink(type = "output", split = FALSE)
[16:20:26.913] if (TRUE) {
[16:20:26.913] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[16:20:26.913] }
[16:20:26.913] else {
[16:20:26.913] ...future.result["stdout"] <- base::list(NULL)
[16:20:26.913] }
[16:20:26.913] base::close(...future.stdout)
[16:20:26.913] ...future.stdout <- NULL
[16:20:26.913] }
[16:20:26.913] ...future.result$conditions <- ...future.conditions
[16:20:26.913] ...future.result$finished <- base::Sys.time()
[16:20:26.913] ...future.result
[16:20:26.913] }
[16:20:26.920] - Launch lazy future ... done
[16:20:26.921] run() for 'MiraiFuture' ... done
[1] 6
[16:20:26.924] ** Sum function 'B' with plan('mirai_cluster') ...function (x, ...)
{
sumt <- function(x) {
message("Arguments '...' exists: ", exists("...", inherits = TRUE))
y %<-% {
sum(x, ...)
}
y
}
sumt(x)
}
Arguments '...' exists: TRUE
[16:20:26.925] getGlobalsAndPackages() ...
[16:20:26.925] Searching for globals...
[16:20:26.926] - globals found: [4] '{', 'sum', 'x', '...'
[16:20:26.927] Searching for globals ... DONE
[16:20:26.927] Resolving globals: FALSE
[16:20:26.927] Tweak future expression to call with '...' arguments ...
[16:20:26.927] {
[16:20:26.927] do.call(function(...) {
[16:20:26.927] sum(x, ...)
[16:20:26.927] }, args = future.call.arguments)
[16:20:26.927] }
[16:20:26.927] Tweak future expression to call with '...' arguments ... DONE
[16:20:26.928] The total size of the 2 globals is 112 bytes (112 bytes)
[16:20:26.929] The total size of the 2 globals exported for future expression ('{; sum(x, ...); }') is 112 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (56 bytes of class 'numeric') and 'future.call.arguments' (56 bytes of class 'list')
[16:20:26.929] - globals: [2] 'x', 'future.call.arguments'
[16:20:26.929]
[16:20:26.930] getGlobalsAndPackages() ... DONE
[16:20:26.930] run() for 'Future' ...
[16:20:26.930] - state: 'created'
[16:20:26.930] - Future backend: 'FutureStrategy', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function'
[16:20:26.934] - Future class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[16:20:26.935] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ...
[16:20:26.935] - Field: 'label'
[16:20:26.935] - Field: 'local'
[16:20:26.935] - Field: 'owner'
[16:20:26.935] - Field: 'envir'
[16:20:26.936] - Field: 'packages'
[16:20:26.936] - Field: 'gc'
[16:20:26.936] - Field: 'conditions'
[16:20:26.936] - Field: 'expr'
[16:20:26.936] - Field: 'uuid'
[16:20:26.936] - Field: 'seed'
[16:20:26.937] - Field: 'version'
[16:20:26.937] - Field: 'result'
[16:20:26.937] - Field: 'asynchronous'
[16:20:26.937] - Field: 'calls'
[16:20:26.937] - Field: 'globals'
[16:20:26.937] - Field: 'stdout'
[16:20:26.937] - Field: 'earlySignal'
[16:20:26.938] - Field: 'lazy'
[16:20:26.938] - Field: 'state'
[16:20:26.938] - Field: '.cluster'
[16:20:26.938] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ... done
[16:20:26.938] - Launch lazy future ...
[16:20:26.938] Packages needed by the future expression (n = 0): <none>
[16:20:26.939] Packages needed by future strategies (n = 0): <none>
[16:20:26.939] {
[16:20:26.939] {
[16:20:26.939] {
[16:20:26.939] ...future.startTime <- base::Sys.time()
[16:20:26.939] {
[16:20:26.939] {
[16:20:26.939] {
[16:20:26.939] base::local({
[16:20:26.939] has_future <- base::requireNamespace("future",
[16:20:26.939] quietly = TRUE)
[16:20:26.939] if (has_future) {
[16:20:26.939] ns <- base::getNamespace("future")
[16:20:26.939] version <- ns[[".package"]][["version"]]
[16:20:26.939] if (is.null(version))
[16:20:26.939] version <- utils::packageVersion("future")
[16:20:26.939] }
[16:20:26.939] else {
[16:20:26.939] version <- NULL
[16:20:26.939] }
[16:20:26.939] if (!has_future || version < "1.8.0") {
[16:20:26.939] info <- base::c(r_version = base::gsub("R version ",
[16:20:26.939] "", base::R.version$version.string),
[16:20:26.939] platform = base::sprintf("%s (%s-bit)",
[16:20:26.939] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[16:20:26.939] os = base::paste(base::Sys.info()[base::c("sysname",
[16:20:26.939] "release", "version")], collapse = " "),
[16:20:26.939] hostname = base::Sys.info()[["nodename"]])
[16:20:26.939] info <- base::sprintf("%s: %s", base::names(info),
[16:20:26.939] info)
[16:20:26.939] info <- base::paste(info, collapse = "; ")
[16:20:26.939] if (!has_future) {
[16:20:26.939] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[16:20:26.939] info)
[16:20:26.939] }
[16:20:26.939] else {
[16:20:26.939] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[16:20:26.939] info, version)
[16:20:26.939] }
[16:20:26.939] base::stop(msg)
[16:20:26.939] }
[16:20:26.939] })
[16:20:26.939] }
[16:20:26.939] ...future.strategy.old <- future::plan("list")
[16:20:26.939] options(future.plan = NULL)
[16:20:26.939] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:26.939] future::plan("default", .cleanup = FALSE, .init = FALSE)
[16:20:26.939] }
[16:20:26.939] ...future.workdir <- getwd()
[16:20:26.939] }
[16:20:26.939] ...future.oldOptions <- base::as.list(base::.Options)
[16:20:26.939] ...future.oldEnvVars <- base::Sys.getenv()
[16:20:26.939] }
[16:20:26.939] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[16:20:26.939] future.globals.maxSize = NULL, future.globals.method = NULL,
[16:20:26.939] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[16:20:26.939] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[16:20:26.939] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[16:20:26.939] future.stdout.windows.reencode = NULL, width = 80L)
[16:20:26.939] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[16:20:26.939] base::names(...future.oldOptions))
[16:20:26.939] }
[16:20:26.939] if (FALSE) {
[16:20:26.939] }
[16:20:26.939] else {
[16:20:26.939] if (TRUE) {
[16:20:26.939] ...future.stdout <- base::rawConnection(base::raw(0L),
[16:20:26.939] open = "w")
[16:20:26.939] }
[16:20:26.939] else {
[16:20:26.939] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[16:20:26.939] windows = "NUL", "/dev/null"), open = "w")
[16:20:26.939] }
[16:20:26.939] base::sink(...future.stdout, type = "output", split = FALSE)
[16:20:26.939] base::on.exit(if (!base::is.null(...future.stdout)) {
[16:20:26.939] base::sink(type = "output", split = FALSE)
[16:20:26.939] base::close(...future.stdout)
[16:20:26.939] }, add = TRUE)
[16:20:26.939] }
[16:20:26.939] ...future.frame <- base::sys.nframe()
[16:20:26.939] ...future.conditions <- base::list()
[16:20:26.939] ...future.rng <- base::globalenv()$.Random.seed
[16:20:26.939] if (FALSE) {
[16:20:26.939] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[16:20:26.939] "...future.value", "...future.globalenv.names", ".Random.seed")
[16:20:26.939] }
[16:20:26.939] ...future.result <- base::tryCatch({
[16:20:26.939] base::withCallingHandlers({
[16:20:26.939] ...future.value <- base::withVisible(base::local({
[16:20:26.939] do.call(function(...) {
[16:20:26.939] sum(x, ...)
[16:20:26.939] }, args = future.call.arguments)
[16:20:26.939] }))
[16:20:26.939] future::FutureResult(value = ...future.value$value,
[16:20:26.939] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[16:20:26.939] ...future.rng), globalenv = if (FALSE)
[16:20:26.939] list(added = base::setdiff(base::names(base::.GlobalEnv),
[16:20:26.939] ...future.globalenv.names))
[16:20:26.939] else NULL, started = ...future.startTime, version = "1.8")
[16:20:26.939] }, condition = base::local({
[16:20:26.939] c <- base::c
[16:20:26.939] inherits <- base::inherits
[16:20:26.939] invokeRestart <- base::invokeRestart
[16:20:26.939] length <- base::length
[16:20:26.939] list <- base::list
[16:20:26.939] seq.int <- base::seq.int
[16:20:26.939] signalCondition <- base::signalCondition
[16:20:26.939] sys.calls <- base::sys.calls
[16:20:26.939] `[[` <- base::`[[`
[16:20:26.939] `+` <- base::`+`
[16:20:26.939] `<<-` <- base::`<<-`
[16:20:26.939] sysCalls <- function(calls = sys.calls(), from = 1L) {
[16:20:26.939] calls[seq.int(from = from + 12L, to = length(calls) -
[16:20:26.939] 3L)]
[16:20:26.939] }
[16:20:26.939] function(cond) {
[16:20:26.939] is_error <- inherits(cond, "error")
[16:20:26.939] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[16:20:26.939] NULL)
[16:20:26.939] if (is_error) {
[16:20:26.939] sessionInformation <- function() {
[16:20:26.939] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[16:20:26.939] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[16:20:26.939] search = base::search(), system = base::Sys.info())
[16:20:26.939] }
[16:20:26.939] ...future.conditions[[length(...future.conditions) +
[16:20:26.939] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[16:20:26.939] cond$call), session = sessionInformation(),
[16:20:26.939] timestamp = base::Sys.time(), signaled = 0L)
[16:20:26.939] signalCondition(cond)
[16:20:26.939] }
[16:20:26.939] else if (!ignore && TRUE && inherits(cond, "condition")) {
[16:20:26.939] signal <- FALSE && inherits(cond, character(0))
[16:20:26.939] ...future.conditions[[length(...future.conditions) +
[16:20:26.939] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[16:20:26.939] if (FALSE && !signal) {
[16:20:26.939] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:26.939] {
[16:20:26.939] inherits <- base::inherits
[16:20:26.939] invokeRestart <- base::invokeRestart
[16:20:26.939] is.null <- base::is.null
[16:20:26.939] muffled <- FALSE
[16:20:26.939] if (inherits(cond, "message")) {
[16:20:26.939] muffled <- grepl(pattern, "muffleMessage")
[16:20:26.939] if (muffled)
[16:20:26.939] invokeRestart("muffleMessage")
[16:20:26.939] }
[16:20:26.939] else if (inherits(cond, "warning")) {
[16:20:26.939] muffled <- grepl(pattern, "muffleWarning")
[16:20:26.939] if (muffled)
[16:20:26.939] invokeRestart("muffleWarning")
[16:20:26.939] }
[16:20:26.939] else if (inherits(cond, "condition")) {
[16:20:26.939] if (!is.null(pattern)) {
[16:20:26.939] computeRestarts <- base::computeRestarts
[16:20:26.939] grepl <- base::grepl
[16:20:26.939] restarts <- computeRestarts(cond)
[16:20:26.939] for (restart in restarts) {
[16:20:26.939] name <- restart$name
[16:20:26.939] if (is.null(name))
[16:20:26.939] next
[16:20:26.939] if (!grepl(pattern, name))
[16:20:26.939] next
[16:20:26.939] invokeRestart(restart)
[16:20:26.939] muffled <- TRUE
[16:20:26.939] break
[16:20:26.939] }
[16:20:26.939] }
[16:20:26.939] }
[16:20:26.939] invisible(muffled)
[16:20:26.939] }
[16:20:26.939] muffleCondition(cond, pattern = "^muffle")
[16:20:26.939] }
[16:20:26.939] }
[16:20:26.939] else {
[16:20:26.939] if (TRUE) {
[16:20:26.939] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:26.939] {
[16:20:26.939] inherits <- base::inherits
[16:20:26.939] invokeRestart <- base::invokeRestart
[16:20:26.939] is.null <- base::is.null
[16:20:26.939] muffled <- FALSE
[16:20:26.939] if (inherits(cond, "message")) {
[16:20:26.939] muffled <- grepl(pattern, "muffleMessage")
[16:20:26.939] if (muffled)
[16:20:26.939] invokeRestart("muffleMessage")
[16:20:26.939] }
[16:20:26.939] else if (inherits(cond, "warning")) {
[16:20:26.939] muffled <- grepl(pattern, "muffleWarning")
[16:20:26.939] if (muffled)
[16:20:26.939] invokeRestart("muffleWarning")
[16:20:26.939] }
[16:20:26.939] else if (inherits(cond, "condition")) {
[16:20:26.939] if (!is.null(pattern)) {
[16:20:26.939] computeRestarts <- base::computeRestarts
[16:20:26.939] grepl <- base::grepl
[16:20:26.939] restarts <- computeRestarts(cond)
[16:20:26.939] for (restart in restarts) {
[16:20:26.939] name <- restart$name
[16:20:26.939] if (is.null(name))
[16:20:26.939] next
[16:20:26.939] if (!grepl(pattern, name))
[16:20:26.939] next
[16:20:26.939] invokeRestart(restart)
[16:20:26.939] muffled <- TRUE
[16:20:26.939] break
[16:20:26.939] }
[16:20:26.939] }
[16:20:26.939] }
[16:20:26.939] invisible(muffled)
[16:20:26.939] }
[16:20:26.939] muffleCondition(cond, pattern = "^muffle")
[16:20:26.939] }
[16:20:26.939] }
[16:20:26.939] }
[16:20:26.939] }))
[16:20:26.939] }, error = function(ex) {
[16:20:26.939] base::structure(base::list(value = NULL, visible = NULL,
[16:20:26.939] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[16:20:26.939] ...future.rng), started = ...future.startTime,
[16:20:26.939] finished = Sys.time(), session_uuid = NA_character_,
[16:20:26.939] version = "1.8"), class = "FutureResult")
[16:20:26.939] }, finally = {
[16:20:26.939] if (!identical(...future.workdir, getwd()))
[16:20:26.939] setwd(...future.workdir)
[16:20:26.939] {
[16:20:26.939] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[16:20:26.939] ...future.oldOptions$nwarnings <- NULL
[16:20:26.939] }
[16:20:26.939] base::options(...future.oldOptions)
[16:20:26.939] if (.Platform$OS.type == "windows") {
[16:20:26.939] old_names <- names(...future.oldEnvVars)
[16:20:26.939] envs <- base::Sys.getenv()
[16:20:26.939] names <- names(envs)
[16:20:26.939] common <- intersect(names, old_names)
[16:20:26.939] added <- setdiff(names, old_names)
[16:20:26.939] removed <- setdiff(old_names, names)
[16:20:26.939] changed <- common[...future.oldEnvVars[common] !=
[16:20:26.939] envs[common]]
[16:20:26.939] NAMES <- toupper(changed)
[16:20:26.939] args <- list()
[16:20:26.939] for (kk in seq_along(NAMES)) {
[16:20:26.939] name <- changed[[kk]]
[16:20:26.939] NAME <- NAMES[[kk]]
[16:20:26.939] if (name != NAME && is.element(NAME, old_names))
[16:20:26.939] next
[16:20:26.939] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:26.939] }
[16:20:26.939] NAMES <- toupper(added)
[16:20:26.939] for (kk in seq_along(NAMES)) {
[16:20:26.939] name <- added[[kk]]
[16:20:26.939] NAME <- NAMES[[kk]]
[16:20:26.939] if (name != NAME && is.element(NAME, old_names))
[16:20:26.939] next
[16:20:26.939] args[[name]] <- ""
[16:20:26.939] }
[16:20:26.939] NAMES <- toupper(removed)
[16:20:26.939] for (kk in seq_along(NAMES)) {
[16:20:26.939] name <- removed[[kk]]
[16:20:26.939] NAME <- NAMES[[kk]]
[16:20:26.939] if (name != NAME && is.element(NAME, old_names))
[16:20:26.939] next
[16:20:26.939] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:26.939] }
[16:20:26.939] if (length(args) > 0)
[16:20:26.939] base::do.call(base::Sys.setenv, args = args)
[16:20:26.939] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[16:20:26.939] }
[16:20:26.939] else {
[16:20:26.939] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[16:20:26.939] }
[16:20:26.939] {
[16:20:26.939] if (base::length(...future.futureOptionsAdded) >
[16:20:26.939] 0L) {
[16:20:26.939] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[16:20:26.939] base::names(opts) <- ...future.futureOptionsAdded
[16:20:26.939] base::options(opts)
[16:20:26.939] }
[16:20:26.939] {
[16:20:26.939] NULL
[16:20:26.939] options(future.plan = NULL)
[16:20:26.939] if (is.na(NA_character_))
[16:20:26.939] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:26.939] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[16:20:26.939] future::plan(...future.strategy.old, .cleanup = FALSE,
[16:20:26.939] .init = FALSE)
[16:20:26.939] }
[16:20:26.939] }
[16:20:26.939] }
[16:20:26.939] })
[16:20:26.939] if (TRUE) {
[16:20:26.939] base::sink(type = "output", split = FALSE)
[16:20:26.939] if (TRUE) {
[16:20:26.939] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[16:20:26.939] }
[16:20:26.939] else {
[16:20:26.939] ...future.result["stdout"] <- base::list(NULL)
[16:20:26.939] }
[16:20:26.939] base::close(...future.stdout)
[16:20:26.939] ...future.stdout <- NULL
[16:20:26.939] }
[16:20:26.939] ...future.result$conditions <- ...future.conditions
[16:20:26.939] ...future.result$finished <- base::Sys.time()
[16:20:26.939] ...future.result
[16:20:26.939] }
[16:20:26.943] - Launch lazy future ... done
[16:20:26.944] run() for 'MiraiFuture' ... done
[1] 6
[16:20:26.946] ** Sum function 'C' with plan('mirai_cluster') ...function (x, y)
{
message("Arguments '...' exists: ", exists("...", inherits = TRUE))
y %<-% {
sum(x, y)
}
y
}
Arguments '...' exists: FALSE
[16:20:26.946] getGlobalsAndPackages() ...
[16:20:26.947] Searching for globals...
[16:20:26.948] - globals found: [4] '{', 'sum', 'x', 'y'
[16:20:26.948] Searching for globals ... DONE
[16:20:26.948] Resolving globals: FALSE
[16:20:26.949] The total size of the 2 globals is 112 bytes (112 bytes)
[16:20:26.949] The total size of the 2 globals exported for future expression ('{; sum(x, y); }') is 112 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (56 bytes of class 'numeric') and 'y' (56 bytes of class 'numeric')
[16:20:26.950] - globals: [2] 'x', 'y'
[16:20:26.950]
[16:20:26.950] getGlobalsAndPackages() ... DONE
[16:20:26.950] run() for 'Future' ...
[16:20:26.950] - state: 'created'
[16:20:26.951] - Future backend: 'FutureStrategy', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function'
[16:20:26.951] - Future class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[16:20:26.951] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ...
[16:20:26.951] - Field: 'label'
[16:20:26.951] - Field: 'local'
[16:20:26.952] - Field: 'owner'
[16:20:26.952] - Field: 'envir'
[16:20:26.952] - Field: 'packages'
[16:20:26.952] - Field: 'gc'
[16:20:26.952] - Field: 'conditions'
[16:20:26.952] - Field: 'expr'
[16:20:26.953] - Field: 'uuid'
[16:20:26.953] - Field: 'seed'
[16:20:26.953] - Field: 'version'
[16:20:26.953] - Field: 'result'
[16:20:26.953] - Field: 'asynchronous'
[16:20:26.953] - Field: 'calls'
[16:20:26.953] - Field: 'globals'
[16:20:26.954] - Field: 'stdout'
[16:20:26.954] - Field: 'earlySignal'
[16:20:26.954] - Field: 'lazy'
[16:20:26.954] - Field: 'state'
[16:20:26.954] - Field: '.cluster'
[16:20:26.954] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ... done
[16:20:26.955] - Launch lazy future ...
[16:20:26.955] Packages needed by the future expression (n = 0): <none>
[16:20:26.955] Packages needed by future strategies (n = 0): <none>
[16:20:26.956] {
[16:20:26.956] {
[16:20:26.956] {
[16:20:26.956] ...future.startTime <- base::Sys.time()
[16:20:26.956] {
[16:20:26.956] {
[16:20:26.956] {
[16:20:26.956] base::local({
[16:20:26.956] has_future <- base::requireNamespace("future",
[16:20:26.956] quietly = TRUE)
[16:20:26.956] if (has_future) {
[16:20:26.956] ns <- base::getNamespace("future")
[16:20:26.956] version <- ns[[".package"]][["version"]]
[16:20:26.956] if (is.null(version))
[16:20:26.956] version <- utils::packageVersion("future")
[16:20:26.956] }
[16:20:26.956] else {
[16:20:26.956] version <- NULL
[16:20:26.956] }
[16:20:26.956] if (!has_future || version < "1.8.0") {
[16:20:26.956] info <- base::c(r_version = base::gsub("R version ",
[16:20:26.956] "", base::R.version$version.string),
[16:20:26.956] platform = base::sprintf("%s (%s-bit)",
[16:20:26.956] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[16:20:26.956] os = base::paste(base::Sys.info()[base::c("sysname",
[16:20:26.956] "release", "version")], collapse = " "),
[16:20:26.956] hostname = base::Sys.info()[["nodename"]])
[16:20:26.956] info <- base::sprintf("%s: %s", base::names(info),
[16:20:26.956] info)
[16:20:26.956] info <- base::paste(info, collapse = "; ")
[16:20:26.956] if (!has_future) {
[16:20:26.956] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[16:20:26.956] info)
[16:20:26.956] }
[16:20:26.956] else {
[16:20:26.956] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[16:20:26.956] info, version)
[16:20:26.956] }
[16:20:26.956] base::stop(msg)
[16:20:26.956] }
[16:20:26.956] })
[16:20:26.956] }
[16:20:26.956] ...future.strategy.old <- future::plan("list")
[16:20:26.956] options(future.plan = NULL)
[16:20:26.956] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:26.956] future::plan("default", .cleanup = FALSE, .init = FALSE)
[16:20:26.956] }
[16:20:26.956] ...future.workdir <- getwd()
[16:20:26.956] }
[16:20:26.956] ...future.oldOptions <- base::as.list(base::.Options)
[16:20:26.956] ...future.oldEnvVars <- base::Sys.getenv()
[16:20:26.956] }
[16:20:26.956] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[16:20:26.956] future.globals.maxSize = NULL, future.globals.method = NULL,
[16:20:26.956] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[16:20:26.956] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[16:20:26.956] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[16:20:26.956] future.stdout.windows.reencode = NULL, width = 80L)
[16:20:26.956] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[16:20:26.956] base::names(...future.oldOptions))
[16:20:26.956] }
[16:20:26.956] if (FALSE) {
[16:20:26.956] }
[16:20:26.956] else {
[16:20:26.956] if (TRUE) {
[16:20:26.956] ...future.stdout <- base::rawConnection(base::raw(0L),
[16:20:26.956] open = "w")
[16:20:26.956] }
[16:20:26.956] else {
[16:20:26.956] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[16:20:26.956] windows = "NUL", "/dev/null"), open = "w")
[16:20:26.956] }
[16:20:26.956] base::sink(...future.stdout, type = "output", split = FALSE)
[16:20:26.956] base::on.exit(if (!base::is.null(...future.stdout)) {
[16:20:26.956] base::sink(type = "output", split = FALSE)
[16:20:26.956] base::close(...future.stdout)
[16:20:26.956] }, add = TRUE)
[16:20:26.956] }
[16:20:26.956] ...future.frame <- base::sys.nframe()
[16:20:26.956] ...future.conditions <- base::list()
[16:20:26.956] ...future.rng <- base::globalenv()$.Random.seed
[16:20:26.956] if (FALSE) {
[16:20:26.956] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[16:20:26.956] "...future.value", "...future.globalenv.names", ".Random.seed")
[16:20:26.956] }
[16:20:26.956] ...future.result <- base::tryCatch({
[16:20:26.956] base::withCallingHandlers({
[16:20:26.956] ...future.value <- base::withVisible(base::local({
[16:20:26.956] sum(x, y)
[16:20:26.956] }))
[16:20:26.956] future::FutureResult(value = ...future.value$value,
[16:20:26.956] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[16:20:26.956] ...future.rng), globalenv = if (FALSE)
[16:20:26.956] list(added = base::setdiff(base::names(base::.GlobalEnv),
[16:20:26.956] ...future.globalenv.names))
[16:20:26.956] else NULL, started = ...future.startTime, version = "1.8")
[16:20:26.956] }, condition = base::local({
[16:20:26.956] c <- base::c
[16:20:26.956] inherits <- base::inherits
[16:20:26.956] invokeRestart <- base::invokeRestart
[16:20:26.956] length <- base::length
[16:20:26.956] list <- base::list
[16:20:26.956] seq.int <- base::seq.int
[16:20:26.956] signalCondition <- base::signalCondition
[16:20:26.956] sys.calls <- base::sys.calls
[16:20:26.956] `[[` <- base::`[[`
[16:20:26.956] `+` <- base::`+`
[16:20:26.956] `<<-` <- base::`<<-`
[16:20:26.956] sysCalls <- function(calls = sys.calls(), from = 1L) {
[16:20:26.956] calls[seq.int(from = from + 12L, to = length(calls) -
[16:20:26.956] 3L)]
[16:20:26.956] }
[16:20:26.956] function(cond) {
[16:20:26.956] is_error <- inherits(cond, "error")
[16:20:26.956] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[16:20:26.956] NULL)
[16:20:26.956] if (is_error) {
[16:20:26.956] sessionInformation <- function() {
[16:20:26.956] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[16:20:26.956] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[16:20:26.956] search = base::search(), system = base::Sys.info())
[16:20:26.956] }
[16:20:26.956] ...future.conditions[[length(...future.conditions) +
[16:20:26.956] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[16:20:26.956] cond$call), session = sessionInformation(),
[16:20:26.956] timestamp = base::Sys.time(), signaled = 0L)
[16:20:26.956] signalCondition(cond)
[16:20:26.956] }
[16:20:26.956] else if (!ignore && TRUE && inherits(cond, "condition")) {
[16:20:26.956] signal <- FALSE && inherits(cond, character(0))
[16:20:26.956] ...future.conditions[[length(...future.conditions) +
[16:20:26.956] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[16:20:26.956] if (FALSE && !signal) {
[16:20:26.956] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:26.956] {
[16:20:26.956] inherits <- base::inherits
[16:20:26.956] invokeRestart <- base::invokeRestart
[16:20:26.956] is.null <- base::is.null
[16:20:26.956] muffled <- FALSE
[16:20:26.956] if (inherits(cond, "message")) {
[16:20:26.956] muffled <- grepl(pattern, "muffleMessage")
[16:20:26.956] if (muffled)
[16:20:26.956] invokeRestart("muffleMessage")
[16:20:26.956] }
[16:20:26.956] else if (inherits(cond, "warning")) {
[16:20:26.956] muffled <- grepl(pattern, "muffleWarning")
[16:20:26.956] if (muffled)
[16:20:26.956] invokeRestart("muffleWarning")
[16:20:26.956] }
[16:20:26.956] else if (inherits(cond, "condition")) {
[16:20:26.956] if (!is.null(pattern)) {
[16:20:26.956] computeRestarts <- base::computeRestarts
[16:20:26.956] grepl <- base::grepl
[16:20:26.956] restarts <- computeRestarts(cond)
[16:20:26.956] for (restart in restarts) {
[16:20:26.956] name <- restart$name
[16:20:26.956] if (is.null(name))
[16:20:26.956] next
[16:20:26.956] if (!grepl(pattern, name))
[16:20:26.956] next
[16:20:26.956] invokeRestart(restart)
[16:20:26.956] muffled <- TRUE
[16:20:26.956] break
[16:20:26.956] }
[16:20:26.956] }
[16:20:26.956] }
[16:20:26.956] invisible(muffled)
[16:20:26.956] }
[16:20:26.956] muffleCondition(cond, pattern = "^muffle")
[16:20:26.956] }
[16:20:26.956] }
[16:20:26.956] else {
[16:20:26.956] if (TRUE) {
[16:20:26.956] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:26.956] {
[16:20:26.956] inherits <- base::inherits
[16:20:26.956] invokeRestart <- base::invokeRestart
[16:20:26.956] is.null <- base::is.null
[16:20:26.956] muffled <- FALSE
[16:20:26.956] if (inherits(cond, "message")) {
[16:20:26.956] muffled <- grepl(pattern, "muffleMessage")
[16:20:26.956] if (muffled)
[16:20:26.956] invokeRestart("muffleMessage")
[16:20:26.956] }
[16:20:26.956] else if (inherits(cond, "warning")) {
[16:20:26.956] muffled <- grepl(pattern, "muffleWarning")
[16:20:26.956] if (muffled)
[16:20:26.956] invokeRestart("muffleWarning")
[16:20:26.956] }
[16:20:26.956] else if (inherits(cond, "condition")) {
[16:20:26.956] if (!is.null(pattern)) {
[16:20:26.956] computeRestarts <- base::computeRestarts
[16:20:26.956] grepl <- base::grepl
[16:20:26.956] restarts <- computeRestarts(cond)
[16:20:26.956] for (restart in restarts) {
[16:20:26.956] name <- restart$name
[16:20:26.956] if (is.null(name))
[16:20:26.956] next
[16:20:26.956] if (!grepl(pattern, name))
[16:20:26.956] next
[16:20:26.956] invokeRestart(restart)
[16:20:26.956] muffled <- TRUE
[16:20:26.956] break
[16:20:26.956] }
[16:20:26.956] }
[16:20:26.956] }
[16:20:26.956] invisible(muffled)
[16:20:26.956] }
[16:20:26.956] muffleCondition(cond, pattern = "^muffle")
[16:20:26.956] }
[16:20:26.956] }
[16:20:26.956] }
[16:20:26.956] }))
[16:20:26.956] }, error = function(ex) {
[16:20:26.956] base::structure(base::list(value = NULL, visible = NULL,
[16:20:26.956] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[16:20:26.956] ...future.rng), started = ...future.startTime,
[16:20:26.956] finished = Sys.time(), session_uuid = NA_character_,
[16:20:26.956] version = "1.8"), class = "FutureResult")
[16:20:26.956] }, finally = {
[16:20:26.956] if (!identical(...future.workdir, getwd()))
[16:20:26.956] setwd(...future.workdir)
[16:20:26.956] {
[16:20:26.956] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[16:20:26.956] ...future.oldOptions$nwarnings <- NULL
[16:20:26.956] }
[16:20:26.956] base::options(...future.oldOptions)
[16:20:26.956] if (.Platform$OS.type == "windows") {
[16:20:26.956] old_names <- names(...future.oldEnvVars)
[16:20:26.956] envs <- base::Sys.getenv()
[16:20:26.956] names <- names(envs)
[16:20:26.956] common <- intersect(names, old_names)
[16:20:26.956] added <- setdiff(names, old_names)
[16:20:26.956] removed <- setdiff(old_names, names)
[16:20:26.956] changed <- common[...future.oldEnvVars[common] !=
[16:20:26.956] envs[common]]
[16:20:26.956] NAMES <- toupper(changed)
[16:20:26.956] args <- list()
[16:20:26.956] for (kk in seq_along(NAMES)) {
[16:20:26.956] name <- changed[[kk]]
[16:20:26.956] NAME <- NAMES[[kk]]
[16:20:26.956] if (name != NAME && is.element(NAME, old_names))
[16:20:26.956] next
[16:20:26.956] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:26.956] }
[16:20:26.956] NAMES <- toupper(added)
[16:20:26.956] for (kk in seq_along(NAMES)) {
[16:20:26.956] name <- added[[kk]]
[16:20:26.956] NAME <- NAMES[[kk]]
[16:20:26.956] if (name != NAME && is.element(NAME, old_names))
[16:20:26.956] next
[16:20:26.956] args[[name]] <- ""
[16:20:26.956] }
[16:20:26.956] NAMES <- toupper(removed)
[16:20:26.956] for (kk in seq_along(NAMES)) {
[16:20:26.956] name <- removed[[kk]]
[16:20:26.956] NAME <- NAMES[[kk]]
[16:20:26.956] if (name != NAME && is.element(NAME, old_names))
[16:20:26.956] next
[16:20:26.956] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:26.956] }
[16:20:26.956] if (length(args) > 0)
[16:20:26.956] base::do.call(base::Sys.setenv, args = args)
[16:20:26.956] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[16:20:26.956] }
[16:20:26.956] else {
[16:20:26.956] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[16:20:26.956] }
[16:20:26.956] {
[16:20:26.956] if (base::length(...future.futureOptionsAdded) >
[16:20:26.956] 0L) {
[16:20:26.956] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[16:20:26.956] base::names(opts) <- ...future.futureOptionsAdded
[16:20:26.956] base::options(opts)
[16:20:26.956] }
[16:20:26.956] {
[16:20:26.956] NULL
[16:20:26.956] options(future.plan = NULL)
[16:20:26.956] if (is.na(NA_character_))
[16:20:26.956] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:26.956] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[16:20:26.956] future::plan(...future.strategy.old, .cleanup = FALSE,
[16:20:26.956] .init = FALSE)
[16:20:26.956] }
[16:20:26.956] }
[16:20:26.956] }
[16:20:26.956] })
[16:20:26.956] if (TRUE) {
[16:20:26.956] base::sink(type = "output", split = FALSE)
[16:20:26.956] if (TRUE) {
[16:20:26.956] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[16:20:26.956] }
[16:20:26.956] else {
[16:20:26.956] ...future.result["stdout"] <- base::list(NULL)
[16:20:26.956] }
[16:20:26.956] base::close(...future.stdout)
[16:20:26.956] ...future.stdout <- NULL
[16:20:26.956] }
[16:20:26.956] ...future.result$conditions <- ...future.conditions
[16:20:26.956] ...future.result$finished <- base::Sys.time()
[16:20:26.956] ...future.result
[16:20:26.956] }
[16:20:26.959] - Launch lazy future ... done
[16:20:26.960] run() for 'MiraiFuture' ... done
[1] 6
[16:20:26.962] ** Sum function 'D' with plan('mirai_cluster') ...function (x, y)
{
message("Arguments '...' exists: ", exists("...", inherits = TRUE))
y %<-% {
sum(x, y, ...)
}
y
}
Arguments '...' exists: FALSE
[16:20:26.963] getGlobalsAndPackages() ...
[16:20:26.963] Searching for globals...
[16:20:26.965] - globals found: [5] '{', 'sum', 'x', 'y', '...'
[16:20:26.965] Searching for globals ... DONE
[16:20:26.965] Resolving globals: FALSE
[16:20:26.966] Tweak future expression to call with '...' arguments ...
[16:20:26.966] The total size of the 2 globals is 112 bytes (112 bytes)
[16:20:26.967] The total size of the 2 globals exported for future expression ('{; sum(x, y, ...); }') is 112 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (56 bytes of class 'numeric') and 'y' (56 bytes of class 'numeric')
[16:20:26.967] - globals: [2] 'x', 'y'
[16:20:26.967]
[16:20:26.967] getGlobalsAndPackages() ... DONE
[16:20:26.968] run() for 'Future' ...
[16:20:26.968] - state: 'created'
[16:20:26.968] - Future backend: 'FutureStrategy', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function'
[16:20:26.968] - Future class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[16:20:26.969] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ...
[16:20:26.969] - Field: 'label'
[16:20:26.969] - Field: 'local'
[16:20:26.969] - Field: 'owner'
[16:20:26.969] - Field: 'envir'
[16:20:26.969] - Field: 'packages'
[16:20:26.969] - Field: 'gc'
[16:20:26.970] - Field: 'conditions'
[16:20:26.970] - Field: 'expr'
[16:20:26.970] - Field: 'uuid'
[16:20:26.970] - Field: 'seed'
[16:20:26.970] - Field: 'version'
[16:20:26.970] - Field: 'result'
[16:20:26.971] - Field: 'asynchronous'
[16:20:26.971] - Field: 'calls'
[16:20:26.971] - Field: 'globals'
[16:20:26.971] - Field: 'stdout'
[16:20:26.971] - Field: 'earlySignal'
[16:20:26.971] - Field: 'lazy'
[16:20:26.971] - Field: 'state'
[16:20:26.972] - Field: '.cluster'
[16:20:26.972] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ... done
[16:20:26.972] - Launch lazy future ...
[16:20:26.972] Packages needed by the future expression (n = 0): <none>
[16:20:26.972] Packages needed by future strategies (n = 0): <none>
[16:20:26.973] {
[16:20:26.973] {
[16:20:26.973] {
[16:20:26.973] ...future.startTime <- base::Sys.time()
[16:20:26.973] {
[16:20:26.973] {
[16:20:26.973] {
[16:20:26.973] base::local({
[16:20:26.973] has_future <- base::requireNamespace("future",
[16:20:26.973] quietly = TRUE)
[16:20:26.973] if (has_future) {
[16:20:26.973] ns <- base::getNamespace("future")
[16:20:26.973] version <- ns[[".package"]][["version"]]
[16:20:26.973] if (is.null(version))
[16:20:26.973] version <- utils::packageVersion("future")
[16:20:26.973] }
[16:20:26.973] else {
[16:20:26.973] version <- NULL
[16:20:26.973] }
[16:20:26.973] if (!has_future || version < "1.8.0") {
[16:20:26.973] info <- base::c(r_version = base::gsub("R version ",
[16:20:26.973] "", base::R.version$version.string),
[16:20:26.973] platform = base::sprintf("%s (%s-bit)",
[16:20:26.973] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[16:20:26.973] os = base::paste(base::Sys.info()[base::c("sysname",
[16:20:26.973] "release", "version")], collapse = " "),
[16:20:26.973] hostname = base::Sys.info()[["nodename"]])
[16:20:26.973] info <- base::sprintf("%s: %s", base::names(info),
[16:20:26.973] info)
[16:20:26.973] info <- base::paste(info, collapse = "; ")
[16:20:26.973] if (!has_future) {
[16:20:26.973] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[16:20:26.973] info)
[16:20:26.973] }
[16:20:26.973] else {
[16:20:26.973] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[16:20:26.973] info, version)
[16:20:26.973] }
[16:20:26.973] base::stop(msg)
[16:20:26.973] }
[16:20:26.973] })
[16:20:26.973] }
[16:20:26.973] ...future.strategy.old <- future::plan("list")
[16:20:26.973] options(future.plan = NULL)
[16:20:26.973] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:26.973] future::plan("default", .cleanup = FALSE, .init = FALSE)
[16:20:26.973] }
[16:20:26.973] ...future.workdir <- getwd()
[16:20:26.973] }
[16:20:26.973] ...future.oldOptions <- base::as.list(base::.Options)
[16:20:26.973] ...future.oldEnvVars <- base::Sys.getenv()
[16:20:26.973] }
[16:20:26.973] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[16:20:26.973] future.globals.maxSize = NULL, future.globals.method = NULL,
[16:20:26.973] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[16:20:26.973] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[16:20:26.973] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[16:20:26.973] future.stdout.windows.reencode = NULL, width = 80L)
[16:20:26.973] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[16:20:26.973] base::names(...future.oldOptions))
[16:20:26.973] }
[16:20:26.973] if (FALSE) {
[16:20:26.973] }
[16:20:26.973] else {
[16:20:26.973] if (TRUE) {
[16:20:26.973] ...future.stdout <- base::rawConnection(base::raw(0L),
[16:20:26.973] open = "w")
[16:20:26.973] }
[16:20:26.973] else {
[16:20:26.973] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[16:20:26.973] windows = "NUL", "/dev/null"), open = "w")
[16:20:26.973] }
[16:20:26.973] base::sink(...future.stdout, type = "output", split = FALSE)
[16:20:26.973] base::on.exit(if (!base::is.null(...future.stdout)) {
[16:20:26.973] base::sink(type = "output", split = FALSE)
[16:20:26.973] base::close(...future.stdout)
[16:20:26.973] }, add = TRUE)
[16:20:26.973] }
[16:20:26.973] ...future.frame <- base::sys.nframe()
[16:20:26.973] ...future.conditions <- base::list()
[16:20:26.973] ...future.rng <- base::globalenv()$.Random.seed
[16:20:26.973] if (FALSE) {
[16:20:26.973] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[16:20:26.973] "...future.value", "...future.globalenv.names", ".Random.seed")
[16:20:26.973] }
[16:20:26.973] ...future.result <- base::tryCatch({
[16:20:26.973] base::withCallingHandlers({
[16:20:26.973] ...future.value <- base::withVisible(base::local({
[16:20:26.973] sum(x, y, ...)
[16:20:26.973] }))
[16:20:26.973] future::FutureResult(value = ...future.value$value,
[16:20:26.973] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[16:20:26.973] ...future.rng), globalenv = if (FALSE)
[16:20:26.973] list(added = base::setdiff(base::names(base::.GlobalEnv),
[16:20:26.973] ...future.globalenv.names))
[16:20:26.973] else NULL, started = ...future.startTime, version = "1.8")
[16:20:26.973] }, condition = base::local({
[16:20:26.973] c <- base::c
[16:20:26.973] inherits <- base::inherits
[16:20:26.973] invokeRestart <- base::invokeRestart
[16:20:26.973] length <- base::length
[16:20:26.973] list <- base::list
[16:20:26.973] seq.int <- base::seq.int
[16:20:26.973] signalCondition <- base::signalCondition
[16:20:26.973] sys.calls <- base::sys.calls
[16:20:26.973] `[[` <- base::`[[`
[16:20:26.973] `+` <- base::`+`
[16:20:26.973] `<<-` <- base::`<<-`
[16:20:26.973] sysCalls <- function(calls = sys.calls(), from = 1L) {
[16:20:26.973] calls[seq.int(from = from + 12L, to = length(calls) -
[16:20:26.973] 3L)]
[16:20:26.973] }
[16:20:26.973] function(cond) {
[16:20:26.973] is_error <- inherits(cond, "error")
[16:20:26.973] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[16:20:26.973] NULL)
[16:20:26.973] if (is_error) {
[16:20:26.973] sessionInformation <- function() {
[16:20:26.973] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[16:20:26.973] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[16:20:26.973] search = base::search(), system = base::Sys.info())
[16:20:26.973] }
[16:20:26.973] ...future.conditions[[length(...future.conditions) +
[16:20:26.973] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[16:20:26.973] cond$call), session = sessionInformation(),
[16:20:26.973] timestamp = base::Sys.time(), signaled = 0L)
[16:20:26.973] signalCondition(cond)
[16:20:26.973] }
[16:20:26.973] else if (!ignore && TRUE && inherits(cond, "condition")) {
[16:20:26.973] signal <- FALSE && inherits(cond, character(0))
[16:20:26.973] ...future.conditions[[length(...future.conditions) +
[16:20:26.973] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[16:20:26.973] if (FALSE && !signal) {
[16:20:26.973] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:26.973] {
[16:20:26.973] inherits <- base::inherits
[16:20:26.973] invokeRestart <- base::invokeRestart
[16:20:26.973] is.null <- base::is.null
[16:20:26.973] muffled <- FALSE
[16:20:26.973] if (inherits(cond, "message")) {
[16:20:26.973] muffled <- grepl(pattern, "muffleMessage")
[16:20:26.973] if (muffled)
[16:20:26.973] invokeRestart("muffleMessage")
[16:20:26.973] }
[16:20:26.973] else if (inherits(cond, "warning")) {
[16:20:26.973] muffled <- grepl(pattern, "muffleWarning")
[16:20:26.973] if (muffled)
[16:20:26.973] invokeRestart("muffleWarning")
[16:20:26.973] }
[16:20:26.973] else if (inherits(cond, "condition")) {
[16:20:26.973] if (!is.null(pattern)) {
[16:20:26.973] computeRestarts <- base::computeRestarts
[16:20:26.973] grepl <- base::grepl
[16:20:26.973] restarts <- computeRestarts(cond)
[16:20:26.973] for (restart in restarts) {
[16:20:26.973] name <- restart$name
[16:20:26.973] if (is.null(name))
[16:20:26.973] next
[16:20:26.973] if (!grepl(pattern, name))
[16:20:26.973] next
[16:20:26.973] invokeRestart(restart)
[16:20:26.973] muffled <- TRUE
[16:20:26.973] break
[16:20:26.973] }
[16:20:26.973] }
[16:20:26.973] }
[16:20:26.973] invisible(muffled)
[16:20:26.973] }
[16:20:26.973] muffleCondition(cond, pattern = "^muffle")
[16:20:26.973] }
[16:20:26.973] }
[16:20:26.973] else {
[16:20:26.973] if (TRUE) {
[16:20:26.973] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:26.973] {
[16:20:26.973] inherits <- base::inherits
[16:20:26.973] invokeRestart <- base::invokeRestart
[16:20:26.973] is.null <- base::is.null
[16:20:26.973] muffled <- FALSE
[16:20:26.973] if (inherits(cond, "message")) {
[16:20:26.973] muffled <- grepl(pattern, "muffleMessage")
[16:20:26.973] if (muffled)
[16:20:26.973] invokeRestart("muffleMessage")
[16:20:26.973] }
[16:20:26.973] else if (inherits(cond, "warning")) {
[16:20:26.973] muffled <- grepl(pattern, "muffleWarning")
[16:20:26.973] if (muffled)
[16:20:26.973] invokeRestart("muffleWarning")
[16:20:26.973] }
[16:20:26.973] else if (inherits(cond, "condition")) {
[16:20:26.973] if (!is.null(pattern)) {
[16:20:26.973] computeRestarts <- base::computeRestarts
[16:20:26.973] grepl <- base::grepl
[16:20:26.973] restarts <- computeRestarts(cond)
[16:20:26.973] for (restart in restarts) {
[16:20:26.973] name <- restart$name
[16:20:26.973] if (is.null(name))
[16:20:26.973] next
[16:20:26.973] if (!grepl(pattern, name))
[16:20:26.973] next
[16:20:26.973] invokeRestart(restart)
[16:20:26.973] muffled <- TRUE
[16:20:26.973] break
[16:20:26.973] }
[16:20:26.973] }
[16:20:26.973] }
[16:20:26.973] invisible(muffled)
[16:20:26.973] }
[16:20:26.973] muffleCondition(cond, pattern = "^muffle")
[16:20:26.973] }
[16:20:26.973] }
[16:20:26.973] }
[16:20:26.973] }))
[16:20:26.973] }, error = function(ex) {
[16:20:26.973] base::structure(base::list(value = NULL, visible = NULL,
[16:20:26.973] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[16:20:26.973] ...future.rng), started = ...future.startTime,
[16:20:26.973] finished = Sys.time(), session_uuid = NA_character_,
[16:20:26.973] version = "1.8"), class = "FutureResult")
[16:20:26.973] }, finally = {
[16:20:26.973] if (!identical(...future.workdir, getwd()))
[16:20:26.973] setwd(...future.workdir)
[16:20:26.973] {
[16:20:26.973] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[16:20:26.973] ...future.oldOptions$nwarnings <- NULL
[16:20:26.973] }
[16:20:26.973] base::options(...future.oldOptions)
[16:20:26.973] if (.Platform$OS.type == "windows") {
[16:20:26.973] old_names <- names(...future.oldEnvVars)
[16:20:26.973] envs <- base::Sys.getenv()
[16:20:26.973] names <- names(envs)
[16:20:26.973] common <- intersect(names, old_names)
[16:20:26.973] added <- setdiff(names, old_names)
[16:20:26.973] removed <- setdiff(old_names, names)
[16:20:26.973] changed <- common[...future.oldEnvVars[common] !=
[16:20:26.973] envs[common]]
[16:20:26.973] NAMES <- toupper(changed)
[16:20:26.973] args <- list()
[16:20:26.973] for (kk in seq_along(NAMES)) {
[16:20:26.973] name <- changed[[kk]]
[16:20:26.973] NAME <- NAMES[[kk]]
[16:20:26.973] if (name != NAME && is.element(NAME, old_names))
[16:20:26.973] next
[16:20:26.973] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:26.973] }
[16:20:26.973] NAMES <- toupper(added)
[16:20:26.973] for (kk in seq_along(NAMES)) {
[16:20:26.973] name <- added[[kk]]
[16:20:26.973] NAME <- NAMES[[kk]]
[16:20:26.973] if (name != NAME && is.element(NAME, old_names))
[16:20:26.973] next
[16:20:26.973] args[[name]] <- ""
[16:20:26.973] }
[16:20:26.973] NAMES <- toupper(removed)
[16:20:26.973] for (kk in seq_along(NAMES)) {
[16:20:26.973] name <- removed[[kk]]
[16:20:26.973] NAME <- NAMES[[kk]]
[16:20:26.973] if (name != NAME && is.element(NAME, old_names))
[16:20:26.973] next
[16:20:26.973] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:26.973] }
[16:20:26.973] if (length(args) > 0)
[16:20:26.973] base::do.call(base::Sys.setenv, args = args)
[16:20:26.973] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[16:20:26.973] }
[16:20:26.973] else {
[16:20:26.973] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[16:20:26.973] }
[16:20:26.973] {
[16:20:26.973] if (base::length(...future.futureOptionsAdded) >
[16:20:26.973] 0L) {
[16:20:26.973] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[16:20:26.973] base::names(opts) <- ...future.futureOptionsAdded
[16:20:26.973] base::options(opts)
[16:20:26.973] }
[16:20:26.973] {
[16:20:26.973] NULL
[16:20:26.973] options(future.plan = NULL)
[16:20:26.973] if (is.na(NA_character_))
[16:20:26.973] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:26.973] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[16:20:26.973] future::plan(...future.strategy.old, .cleanup = FALSE,
[16:20:26.973] .init = FALSE)
[16:20:26.973] }
[16:20:26.973] }
[16:20:26.973] }
[16:20:26.973] })
[16:20:26.973] if (TRUE) {
[16:20:26.973] base::sink(type = "output", split = FALSE)
[16:20:26.973] if (TRUE) {
[16:20:26.973] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[16:20:26.973] }
[16:20:26.973] else {
[16:20:26.973] ...future.result["stdout"] <- base::list(NULL)
[16:20:26.973] }
[16:20:26.973] base::close(...future.stdout)
[16:20:26.973] ...future.stdout <- NULL
[16:20:26.973] }
[16:20:26.973] ...future.result$conditions <- ...future.conditions
[16:20:26.973] ...future.result$finished <- base::Sys.time()
[16:20:26.973] ...future.result
[16:20:26.973] }
[16:20:26.977] - Launch lazy future ... done
[16:20:26.977] run() for 'MiraiFuture' ... done
[16:20:26.980] signalConditions() ...
[16:20:26.981] - include = 'immediateCondition'
[16:20:26.981] - exclude =
[16:20:26.981] - resignal = FALSE
[16:20:26.982] - Number of conditions: 1
[16:20:26.982] signalConditions() ... done
[16:20:26.982] Future state: 'finished'
[16:20:26.982] signalConditions() ...
[16:20:26.983] - include = 'condition'
[16:20:26.983] - exclude = 'immediateCondition'
[16:20:26.983] - resignal = TRUE
[16:20:26.983] - Number of conditions: 1
[16:20:26.984] - Condition #1: 'simpleError', 'error', 'condition'
[16:20:26.986] signalConditions() ... done
<simpleError in eval(quote({ sum(x, y, ...)}), new.env()): '...' used in an incorrect context>
[16:20:26.987] plan(): Setting new future strategy stack:
[16:20:26.987] List of future strategies:
[16:20:26.987] 1. mirai_multisession:
[16:20:26.987] - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
[16:20:26.987] - tweaked: FALSE
[16:20:26.987] - call: plan(strategy, substitute = FALSE)
[16:20:26.988] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
[16:20:26.988] < mirai | $data >
[16:20:26.991] getGlobalsAndPackages() ...
[16:20:26.991] Not searching for globals
[16:20:26.991] - globals: [0] <none>
[16:20:26.991] getGlobalsAndPackages() ... DONE
[16:20:26.992] getGlobalsAndPackages() ...
[16:20:26.992]
[16:20:26.992] - globals: [0] <none>
[16:20:26.992] getGlobalsAndPackages() ... DONE
[16:20:26.993] Packages needed by the future expression (n = 0): <none>
[16:20:26.993] Packages needed by future strategies (n = 0): <none>
[16:20:26.994] {
[16:20:26.994] {
[16:20:26.994] {
[16:20:26.994] ...future.startTime <- base::Sys.time()
[16:20:26.994] {
[16:20:26.994] {
[16:20:26.994] {
[16:20:26.994] base::local({
[16:20:26.994] has_future <- base::requireNamespace("future",
[16:20:26.994] quietly = TRUE)
[16:20:26.994] if (has_future) {
[16:20:26.994] ns <- base::getNamespace("future")
[16:20:26.994] version <- ns[[".package"]][["version"]]
[16:20:26.994] if (is.null(version))
[16:20:26.994] version <- utils::packageVersion("future")
[16:20:26.994] }
[16:20:26.994] else {
[16:20:26.994] version <- NULL
[16:20:26.994] }
[16:20:26.994] if (!has_future || version < "1.8.0") {
[16:20:26.994] info <- base::c(r_version = base::gsub("R version ",
[16:20:26.994] "", base::R.version$version.string),
[16:20:26.994] platform = base::sprintf("%s (%s-bit)",
[16:20:26.994] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[16:20:26.994] os = base::paste(base::Sys.info()[base::c("sysname",
[16:20:26.994] "release", "version")], collapse = " "),
[16:20:26.994] hostname = base::Sys.info()[["nodename"]])
[16:20:26.994] info <- base::sprintf("%s: %s", base::names(info),
[16:20:26.994] info)
[16:20:26.994] info <- base::paste(info, collapse = "; ")
[16:20:26.994] if (!has_future) {
[16:20:26.994] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[16:20:26.994] info)
[16:20:26.994] }
[16:20:26.994] else {
[16:20:26.994] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[16:20:26.994] info, version)
[16:20:26.994] }
[16:20:26.994] base::stop(msg)
[16:20:26.994] }
[16:20:26.994] })
[16:20:26.994] }
[16:20:26.994] ...future.strategy.old <- future::plan("list")
[16:20:26.994] options(future.plan = NULL)
[16:20:26.994] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:26.994] future::plan("default", .cleanup = FALSE, .init = FALSE)
[16:20:26.994] }
[16:20:26.994] ...future.workdir <- getwd()
[16:20:26.994] }
[16:20:26.994] ...future.oldOptions <- base::as.list(base::.Options)
[16:20:26.994] ...future.oldEnvVars <- base::Sys.getenv()
[16:20:26.994] }
[16:20:26.994] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[16:20:26.994] future.globals.maxSize = NULL, future.globals.method = NULL,
[16:20:26.994] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[16:20:26.994] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[16:20:26.994] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[16:20:26.994] future.stdout.windows.reencode = NULL, width = 80L)
[16:20:26.994] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[16:20:26.994] base::names(...future.oldOptions))
[16:20:26.994] }
[16:20:26.994] if (FALSE) {
[16:20:26.994] }
[16:20:26.994] else {
[16:20:26.994] if (TRUE) {
[16:20:26.994] ...future.stdout <- base::rawConnection(base::raw(0L),
[16:20:26.994] open = "w")
[16:20:26.994] }
[16:20:26.994] else {
[16:20:26.994] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[16:20:26.994] windows = "NUL", "/dev/null"), open = "w")
[16:20:26.994] }
[16:20:26.994] base::sink(...future.stdout, type = "output", split = FALSE)
[16:20:26.994] base::on.exit(if (!base::is.null(...future.stdout)) {
[16:20:26.994] base::sink(type = "output", split = FALSE)
[16:20:26.994] base::close(...future.stdout)
[16:20:26.994] }, add = TRUE)
[16:20:26.994] }
[16:20:26.994] ...future.frame <- base::sys.nframe()
[16:20:26.994] ...future.conditions <- base::list()
[16:20:26.994] ...future.rng <- base::globalenv()$.Random.seed
[16:20:26.994] if (FALSE) {
[16:20:26.994] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[16:20:26.994] "...future.value", "...future.globalenv.names", ".Random.seed")
[16:20:26.994] }
[16:20:26.994] ...future.result <- base::tryCatch({
[16:20:26.994] base::withCallingHandlers({
[16:20:26.994] ...future.value <- base::withVisible(base::local(NA))
[16:20:26.994] future::FutureResult(value = ...future.value$value,
[16:20:26.994] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[16:20:26.994] ...future.rng), globalenv = if (FALSE)
[16:20:26.994] list(added = base::setdiff(base::names(base::.GlobalEnv),
[16:20:26.994] ...future.globalenv.names))
[16:20:26.994] else NULL, started = ...future.startTime, version = "1.8")
[16:20:26.994] }, condition = base::local({
[16:20:26.994] c <- base::c
[16:20:26.994] inherits <- base::inherits
[16:20:26.994] invokeRestart <- base::invokeRestart
[16:20:26.994] length <- base::length
[16:20:26.994] list <- base::list
[16:20:26.994] seq.int <- base::seq.int
[16:20:26.994] signalCondition <- base::signalCondition
[16:20:26.994] sys.calls <- base::sys.calls
[16:20:26.994] `[[` <- base::`[[`
[16:20:26.994] `+` <- base::`+`
[16:20:26.994] `<<-` <- base::`<<-`
[16:20:26.994] sysCalls <- function(calls = sys.calls(), from = 1L) {
[16:20:26.994] calls[seq.int(from = from + 12L, to = length(calls) -
[16:20:26.994] 3L)]
[16:20:26.994] }
[16:20:26.994] function(cond) {
[16:20:26.994] is_error <- inherits(cond, "error")
[16:20:26.994] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[16:20:26.994] NULL)
[16:20:26.994] if (is_error) {
[16:20:26.994] sessionInformation <- function() {
[16:20:26.994] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[16:20:26.994] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[16:20:26.994] search = base::search(), system = base::Sys.info())
[16:20:26.994] }
[16:20:26.994] ...future.conditions[[length(...future.conditions) +
[16:20:26.994] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[16:20:26.994] cond$call), session = sessionInformation(),
[16:20:26.994] timestamp = base::Sys.time(), signaled = 0L)
[16:20:26.994] signalCondition(cond)
[16:20:26.994] }
[16:20:26.994] else if (!ignore && TRUE && inherits(cond, "condition")) {
[16:20:26.994] signal <- FALSE && inherits(cond, character(0))
[16:20:26.994] ...future.conditions[[length(...future.conditions) +
[16:20:26.994] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[16:20:26.994] if (FALSE && !signal) {
[16:20:26.994] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:26.994] {
[16:20:26.994] inherits <- base::inherits
[16:20:26.994] invokeRestart <- base::invokeRestart
[16:20:26.994] is.null <- base::is.null
[16:20:26.994] muffled <- FALSE
[16:20:26.994] if (inherits(cond, "message")) {
[16:20:26.994] muffled <- grepl(pattern, "muffleMessage")
[16:20:26.994] if (muffled)
[16:20:26.994] invokeRestart("muffleMessage")
[16:20:26.994] }
[16:20:26.994] else if (inherits(cond, "warning")) {
[16:20:26.994] muffled <- grepl(pattern, "muffleWarning")
[16:20:26.994] if (muffled)
[16:20:26.994] invokeRestart("muffleWarning")
[16:20:26.994] }
[16:20:26.994] else if (inherits(cond, "condition")) {
[16:20:26.994] if (!is.null(pattern)) {
[16:20:26.994] computeRestarts <- base::computeRestarts
[16:20:26.994] grepl <- base::grepl
[16:20:26.994] restarts <- computeRestarts(cond)
[16:20:26.994] for (restart in restarts) {
[16:20:26.994] name <- restart$name
[16:20:26.994] if (is.null(name))
[16:20:26.994] next
[16:20:26.994] if (!grepl(pattern, name))
[16:20:26.994] next
[16:20:26.994] invokeRestart(restart)
[16:20:26.994] muffled <- TRUE
[16:20:26.994] break
[16:20:26.994] }
[16:20:26.994] }
[16:20:26.994] }
[16:20:26.994] invisible(muffled)
[16:20:26.994] }
[16:20:26.994] muffleCondition(cond, pattern = "^muffle")
[16:20:26.994] }
[16:20:26.994] }
[16:20:26.994] else {
[16:20:26.994] if (TRUE) {
[16:20:26.994] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:26.994] {
[16:20:26.994] inherits <- base::inherits
[16:20:26.994] invokeRestart <- base::invokeRestart
[16:20:26.994] is.null <- base::is.null
[16:20:26.994] muffled <- FALSE
[16:20:26.994] if (inherits(cond, "message")) {
[16:20:26.994] muffled <- grepl(pattern, "muffleMessage")
[16:20:26.994] if (muffled)
[16:20:26.994] invokeRestart("muffleMessage")
[16:20:26.994] }
[16:20:26.994] else if (inherits(cond, "warning")) {
[16:20:26.994] muffled <- grepl(pattern, "muffleWarning")
[16:20:26.994] if (muffled)
[16:20:26.994] invokeRestart("muffleWarning")
[16:20:26.994] }
[16:20:26.994] else if (inherits(cond, "condition")) {
[16:20:26.994] if (!is.null(pattern)) {
[16:20:26.994] computeRestarts <- base::computeRestarts
[16:20:26.994] grepl <- base::grepl
[16:20:26.994] restarts <- computeRestarts(cond)
[16:20:26.994] for (restart in restarts) {
[16:20:26.994] name <- restart$name
[16:20:26.994] if (is.null(name))
[16:20:26.994] next
[16:20:26.994] if (!grepl(pattern, name))
[16:20:26.994] next
[16:20:26.994] invokeRestart(restart)
[16:20:26.994] muffled <- TRUE
[16:20:26.994] break
[16:20:26.994] }
[16:20:26.994] }
[16:20:26.994] }
[16:20:26.994] invisible(muffled)
[16:20:26.994] }
[16:20:26.994] muffleCondition(cond, pattern = "^muffle")
[16:20:26.994] }
[16:20:26.994] }
[16:20:26.994] }
[16:20:26.994] }))
[16:20:26.994] }, error = function(ex) {
[16:20:26.994] base::structure(base::list(value = NULL, visible = NULL,
[16:20:26.994] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[16:20:26.994] ...future.rng), started = ...future.startTime,
[16:20:26.994] finished = Sys.time(), session_uuid = NA_character_,
[16:20:26.994] version = "1.8"), class = "FutureResult")
[16:20:26.994] }, finally = {
[16:20:26.994] if (!identical(...future.workdir, getwd()))
[16:20:26.994] setwd(...future.workdir)
[16:20:26.994] {
[16:20:26.994] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[16:20:26.994] ...future.oldOptions$nwarnings <- NULL
[16:20:26.994] }
[16:20:26.994] base::options(...future.oldOptions)
[16:20:26.994] if (.Platform$OS.type == "windows") {
[16:20:26.994] old_names <- names(...future.oldEnvVars)
[16:20:26.994] envs <- base::Sys.getenv()
[16:20:26.994] names <- names(envs)
[16:20:26.994] common <- intersect(names, old_names)
[16:20:26.994] added <- setdiff(names, old_names)
[16:20:26.994] removed <- setdiff(old_names, names)
[16:20:26.994] changed <- common[...future.oldEnvVars[common] !=
[16:20:26.994] envs[common]]
[16:20:26.994] NAMES <- toupper(changed)
[16:20:26.994] args <- list()
[16:20:26.994] for (kk in seq_along(NAMES)) {
[16:20:26.994] name <- changed[[kk]]
[16:20:26.994] NAME <- NAMES[[kk]]
[16:20:26.994] if (name != NAME && is.element(NAME, old_names))
[16:20:26.994] next
[16:20:26.994] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:26.994] }
[16:20:26.994] NAMES <- toupper(added)
[16:20:26.994] for (kk in seq_along(NAMES)) {
[16:20:26.994] name <- added[[kk]]
[16:20:26.994] NAME <- NAMES[[kk]]
[16:20:26.994] if (name != NAME && is.element(NAME, old_names))
[16:20:26.994] next
[16:20:26.994] args[[name]] <- ""
[16:20:26.994] }
[16:20:26.994] NAMES <- toupper(removed)
[16:20:26.994] for (kk in seq_along(NAMES)) {
[16:20:26.994] name <- removed[[kk]]
[16:20:26.994] NAME <- NAMES[[kk]]
[16:20:26.994] if (name != NAME && is.element(NAME, old_names))
[16:20:26.994] next
[16:20:26.994] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:26.994] }
[16:20:26.994] if (length(args) > 0)
[16:20:26.994] base::do.call(base::Sys.setenv, args = args)
[16:20:26.994] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[16:20:26.994] }
[16:20:26.994] else {
[16:20:26.994] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[16:20:26.994] }
[16:20:26.994] {
[16:20:26.994] if (base::length(...future.futureOptionsAdded) >
[16:20:26.994] 0L) {
[16:20:26.994] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[16:20:26.994] base::names(opts) <- ...future.futureOptionsAdded
[16:20:26.994] base::options(opts)
[16:20:26.994] }
[16:20:26.994] {
[16:20:26.994] NULL
[16:20:26.994] options(future.plan = NULL)
[16:20:26.994] if (is.na(NA_character_))
[16:20:26.994] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:26.994] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[16:20:26.994] future::plan(...future.strategy.old, .cleanup = FALSE,
[16:20:26.994] .init = FALSE)
[16:20:26.994] }
[16:20:26.994] }
[16:20:26.994] }
[16:20:26.994] })
[16:20:26.994] if (TRUE) {
[16:20:26.994] base::sink(type = "output", split = FALSE)
[16:20:26.994] if (TRUE) {
[16:20:26.994] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[16:20:26.994] }
[16:20:26.994] else {
[16:20:26.994] ...future.result["stdout"] <- base::list(NULL)
[16:20:26.994] }
[16:20:26.994] base::close(...future.stdout)
[16:20:26.994] ...future.stdout <- NULL
[16:20:26.994] }
[16:20:26.994] ...future.result$conditions <- ...future.conditions
[16:20:26.994] ...future.result$finished <- base::Sys.time()
[16:20:26.994] ...future.result
[16:20:26.994] }
[16:20:27.003] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ... DONE
[16:20:27.004] plan(): nbrOfWorkers() = 2
[16:20:27.004] ** Sum function 'A' with plan('mirai_multisession') ...function (x, ...)
{
message("Arguments '...' exists: ", exists("...", inherits = TRUE))
y %<-% {
sum(x, ...)
}
y
}
Arguments '...' exists: TRUE
[16:20:27.008] getGlobalsAndPackages() ...
[16:20:27.008] Searching for globals...
[16:20:27.010] - globals found: [4] '{', 'sum', 'x', '...'
[16:20:27.010] Searching for globals ... DONE
[16:20:27.011] Resolving globals: FALSE
[16:20:27.011] Tweak future expression to call with '...' arguments ...
[16:20:27.011] {
[16:20:27.011] do.call(function(...) {
[16:20:27.011] sum(x, ...)
[16:20:27.011] }, args = future.call.arguments)
[16:20:27.011] }
[16:20:27.012] Tweak future expression to call with '...' arguments ... DONE
[16:20:27.013] The total size of the 2 globals is 112 bytes (112 bytes)
[16:20:27.014] The total size of the 2 globals exported for future expression ('{; sum(x, ...); }') is 112 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (56 bytes of class 'numeric') and 'future.call.arguments' (56 bytes of class 'list')
[16:20:27.014] - globals: [2] 'x', 'future.call.arguments'
[16:20:27.014]
[16:20:27.014] getGlobalsAndPackages() ... DONE
[16:20:27.015] run() for 'Future' ...
[16:20:27.015] - state: 'created'
[16:20:27.015] - Future backend: 'FutureStrategy', 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function'
[16:20:27.018] - Future class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[16:20:27.018] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ...
[16:20:27.019] - Field: 'label'
[16:20:27.019] - Field: 'local'
[16:20:27.019] - Field: 'owner'
[16:20:27.019] - Field: 'envir'
[16:20:27.019] - Field: 'packages'
[16:20:27.020] - Field: 'gc'
[16:20:27.020] - Field: 'conditions'
[16:20:27.020] - Field: 'expr'
[16:20:27.020] - Field: 'uuid'
[16:20:27.020] - Field: 'seed'
[16:20:27.021] - Field: 'version'
[16:20:27.021] - Field: 'result'
[16:20:27.021] - Field: 'asynchronous'
[16:20:27.022] - Field: 'calls'
[16:20:27.022] - Field: 'globals'
[16:20:27.022] - Field: 'stdout'
[16:20:27.023] - Field: 'earlySignal'
[16:20:27.023] - Field: 'lazy'
[16:20:27.023] - Field: 'state'
[16:20:27.024] - Field: '.cluster'
[16:20:27.024] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ... done
[16:20:27.024] - Launch lazy future ...
[16:20:27.025] Packages needed by the future expression (n = 0): <none>
[16:20:27.025] Packages needed by future strategies (n = 0): <none>
[16:20:27.026] {
[16:20:27.026] {
[16:20:27.026] {
[16:20:27.026] ...future.startTime <- base::Sys.time()
[16:20:27.026] {
[16:20:27.026] {
[16:20:27.026] {
[16:20:27.026] base::local({
[16:20:27.026] has_future <- base::requireNamespace("future",
[16:20:27.026] quietly = TRUE)
[16:20:27.026] if (has_future) {
[16:20:27.026] ns <- base::getNamespace("future")
[16:20:27.026] version <- ns[[".package"]][["version"]]
[16:20:27.026] if (is.null(version))
[16:20:27.026] version <- utils::packageVersion("future")
[16:20:27.026] }
[16:20:27.026] else {
[16:20:27.026] version <- NULL
[16:20:27.026] }
[16:20:27.026] if (!has_future || version < "1.8.0") {
[16:20:27.026] info <- base::c(r_version = base::gsub("R version ",
[16:20:27.026] "", base::R.version$version.string),
[16:20:27.026] platform = base::sprintf("%s (%s-bit)",
[16:20:27.026] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[16:20:27.026] os = base::paste(base::Sys.info()[base::c("sysname",
[16:20:27.026] "release", "version")], collapse = " "),
[16:20:27.026] hostname = base::Sys.info()[["nodename"]])
[16:20:27.026] info <- base::sprintf("%s: %s", base::names(info),
[16:20:27.026] info)
[16:20:27.026] info <- base::paste(info, collapse = "; ")
[16:20:27.026] if (!has_future) {
[16:20:27.026] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[16:20:27.026] info)
[16:20:27.026] }
[16:20:27.026] else {
[16:20:27.026] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[16:20:27.026] info, version)
[16:20:27.026] }
[16:20:27.026] base::stop(msg)
[16:20:27.026] }
[16:20:27.026] })
[16:20:27.026] }
[16:20:27.026] ...future.strategy.old <- future::plan("list")
[16:20:27.026] options(future.plan = NULL)
[16:20:27.026] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:27.026] future::plan("default", .cleanup = FALSE, .init = FALSE)
[16:20:27.026] }
[16:20:27.026] ...future.workdir <- getwd()
[16:20:27.026] }
[16:20:27.026] ...future.oldOptions <- base::as.list(base::.Options)
[16:20:27.026] ...future.oldEnvVars <- base::Sys.getenv()
[16:20:27.026] }
[16:20:27.026] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[16:20:27.026] future.globals.maxSize = NULL, future.globals.method = NULL,
[16:20:27.026] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[16:20:27.026] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[16:20:27.026] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[16:20:27.026] future.stdout.windows.reencode = NULL, width = 80L)
[16:20:27.026] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[16:20:27.026] base::names(...future.oldOptions))
[16:20:27.026] }
[16:20:27.026] if (FALSE) {
[16:20:27.026] }
[16:20:27.026] else {
[16:20:27.026] if (TRUE) {
[16:20:27.026] ...future.stdout <- base::rawConnection(base::raw(0L),
[16:20:27.026] open = "w")
[16:20:27.026] }
[16:20:27.026] else {
[16:20:27.026] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[16:20:27.026] windows = "NUL", "/dev/null"), open = "w")
[16:20:27.026] }
[16:20:27.026] base::sink(...future.stdout, type = "output", split = FALSE)
[16:20:27.026] base::on.exit(if (!base::is.null(...future.stdout)) {
[16:20:27.026] base::sink(type = "output", split = FALSE)
[16:20:27.026] base::close(...future.stdout)
[16:20:27.026] }, add = TRUE)
[16:20:27.026] }
[16:20:27.026] ...future.frame <- base::sys.nframe()
[16:20:27.026] ...future.conditions <- base::list()
[16:20:27.026] ...future.rng <- base::globalenv()$.Random.seed
[16:20:27.026] if (FALSE) {
[16:20:27.026] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[16:20:27.026] "...future.value", "...future.globalenv.names", ".Random.seed")
[16:20:27.026] }
[16:20:27.026] ...future.result <- base::tryCatch({
[16:20:27.026] base::withCallingHandlers({
[16:20:27.026] ...future.value <- base::withVisible(base::local({
[16:20:27.026] do.call(function(...) {
[16:20:27.026] sum(x, ...)
[16:20:27.026] }, args = future.call.arguments)
[16:20:27.026] }))
[16:20:27.026] future::FutureResult(value = ...future.value$value,
[16:20:27.026] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[16:20:27.026] ...future.rng), globalenv = if (FALSE)
[16:20:27.026] list(added = base::setdiff(base::names(base::.GlobalEnv),
[16:20:27.026] ...future.globalenv.names))
[16:20:27.026] else NULL, started = ...future.startTime, version = "1.8")
[16:20:27.026] }, condition = base::local({
[16:20:27.026] c <- base::c
[16:20:27.026] inherits <- base::inherits
[16:20:27.026] invokeRestart <- base::invokeRestart
[16:20:27.026] length <- base::length
[16:20:27.026] list <- base::list
[16:20:27.026] seq.int <- base::seq.int
[16:20:27.026] signalCondition <- base::signalCondition
[16:20:27.026] sys.calls <- base::sys.calls
[16:20:27.026] `[[` <- base::`[[`
[16:20:27.026] `+` <- base::`+`
[16:20:27.026] `<<-` <- base::`<<-`
[16:20:27.026] sysCalls <- function(calls = sys.calls(), from = 1L) {
[16:20:27.026] calls[seq.int(from = from + 12L, to = length(calls) -
[16:20:27.026] 3L)]
[16:20:27.026] }
[16:20:27.026] function(cond) {
[16:20:27.026] is_error <- inherits(cond, "error")
[16:20:27.026] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[16:20:27.026] NULL)
[16:20:27.026] if (is_error) {
[16:20:27.026] sessionInformation <- function() {
[16:20:27.026] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[16:20:27.026] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[16:20:27.026] search = base::search(), system = base::Sys.info())
[16:20:27.026] }
[16:20:27.026] ...future.conditions[[length(...future.conditions) +
[16:20:27.026] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[16:20:27.026] cond$call), session = sessionInformation(),
[16:20:27.026] timestamp = base::Sys.time(), signaled = 0L)
[16:20:27.026] signalCondition(cond)
[16:20:27.026] }
[16:20:27.026] else if (!ignore && TRUE && inherits(cond, "condition")) {
[16:20:27.026] signal <- FALSE && inherits(cond, character(0))
[16:20:27.026] ...future.conditions[[length(...future.conditions) +
[16:20:27.026] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[16:20:27.026] if (FALSE && !signal) {
[16:20:27.026] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:27.026] {
[16:20:27.026] inherits <- base::inherits
[16:20:27.026] invokeRestart <- base::invokeRestart
[16:20:27.026] is.null <- base::is.null
[16:20:27.026] muffled <- FALSE
[16:20:27.026] if (inherits(cond, "message")) {
[16:20:27.026] muffled <- grepl(pattern, "muffleMessage")
[16:20:27.026] if (muffled)
[16:20:27.026] invokeRestart("muffleMessage")
[16:20:27.026] }
[16:20:27.026] else if (inherits(cond, "warning")) {
[16:20:27.026] muffled <- grepl(pattern, "muffleWarning")
[16:20:27.026] if (muffled)
[16:20:27.026] invokeRestart("muffleWarning")
[16:20:27.026] }
[16:20:27.026] else if (inherits(cond, "condition")) {
[16:20:27.026] if (!is.null(pattern)) {
[16:20:27.026] computeRestarts <- base::computeRestarts
[16:20:27.026] grepl <- base::grepl
[16:20:27.026] restarts <- computeRestarts(cond)
[16:20:27.026] for (restart in restarts) {
[16:20:27.026] name <- restart$name
[16:20:27.026] if (is.null(name))
[16:20:27.026] next
[16:20:27.026] if (!grepl(pattern, name))
[16:20:27.026] next
[16:20:27.026] invokeRestart(restart)
[16:20:27.026] muffled <- TRUE
[16:20:27.026] break
[16:20:27.026] }
[16:20:27.026] }
[16:20:27.026] }
[16:20:27.026] invisible(muffled)
[16:20:27.026] }
[16:20:27.026] muffleCondition(cond, pattern = "^muffle")
[16:20:27.026] }
[16:20:27.026] }
[16:20:27.026] else {
[16:20:27.026] if (TRUE) {
[16:20:27.026] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:27.026] {
[16:20:27.026] inherits <- base::inherits
[16:20:27.026] invokeRestart <- base::invokeRestart
[16:20:27.026] is.null <- base::is.null
[16:20:27.026] muffled <- FALSE
[16:20:27.026] if (inherits(cond, "message")) {
[16:20:27.026] muffled <- grepl(pattern, "muffleMessage")
[16:20:27.026] if (muffled)
[16:20:27.026] invokeRestart("muffleMessage")
[16:20:27.026] }
[16:20:27.026] else if (inherits(cond, "warning")) {
[16:20:27.026] muffled <- grepl(pattern, "muffleWarning")
[16:20:27.026] if (muffled)
[16:20:27.026] invokeRestart("muffleWarning")
[16:20:27.026] }
[16:20:27.026] else if (inherits(cond, "condition")) {
[16:20:27.026] if (!is.null(pattern)) {
[16:20:27.026] computeRestarts <- base::computeRestarts
[16:20:27.026] grepl <- base::grepl
[16:20:27.026] restarts <- computeRestarts(cond)
[16:20:27.026] for (restart in restarts) {
[16:20:27.026] name <- restart$name
[16:20:27.026] if (is.null(name))
[16:20:27.026] next
[16:20:27.026] if (!grepl(pattern, name))
[16:20:27.026] next
[16:20:27.026] invokeRestart(restart)
[16:20:27.026] muffled <- TRUE
[16:20:27.026] break
[16:20:27.026] }
[16:20:27.026] }
[16:20:27.026] }
[16:20:27.026] invisible(muffled)
[16:20:27.026] }
[16:20:27.026] muffleCondition(cond, pattern = "^muffle")
[16:20:27.026] }
[16:20:27.026] }
[16:20:27.026] }
[16:20:27.026] }))
[16:20:27.026] }, error = function(ex) {
[16:20:27.026] base::structure(base::list(value = NULL, visible = NULL,
[16:20:27.026] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[16:20:27.026] ...future.rng), started = ...future.startTime,
[16:20:27.026] finished = Sys.time(), session_uuid = NA_character_,
[16:20:27.026] version = "1.8"), class = "FutureResult")
[16:20:27.026] }, finally = {
[16:20:27.026] if (!identical(...future.workdir, getwd()))
[16:20:27.026] setwd(...future.workdir)
[16:20:27.026] {
[16:20:27.026] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[16:20:27.026] ...future.oldOptions$nwarnings <- NULL
[16:20:27.026] }
[16:20:27.026] base::options(...future.oldOptions)
[16:20:27.026] if (.Platform$OS.type == "windows") {
[16:20:27.026] old_names <- names(...future.oldEnvVars)
[16:20:27.026] envs <- base::Sys.getenv()
[16:20:27.026] names <- names(envs)
[16:20:27.026] common <- intersect(names, old_names)
[16:20:27.026] added <- setdiff(names, old_names)
[16:20:27.026] removed <- setdiff(old_names, names)
[16:20:27.026] changed <- common[...future.oldEnvVars[common] !=
[16:20:27.026] envs[common]]
[16:20:27.026] NAMES <- toupper(changed)
[16:20:27.026] args <- list()
[16:20:27.026] for (kk in seq_along(NAMES)) {
[16:20:27.026] name <- changed[[kk]]
[16:20:27.026] NAME <- NAMES[[kk]]
[16:20:27.026] if (name != NAME && is.element(NAME, old_names))
[16:20:27.026] next
[16:20:27.026] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:27.026] }
[16:20:27.026] NAMES <- toupper(added)
[16:20:27.026] for (kk in seq_along(NAMES)) {
[16:20:27.026] name <- added[[kk]]
[16:20:27.026] NAME <- NAMES[[kk]]
[16:20:27.026] if (name != NAME && is.element(NAME, old_names))
[16:20:27.026] next
[16:20:27.026] args[[name]] <- ""
[16:20:27.026] }
[16:20:27.026] NAMES <- toupper(removed)
[16:20:27.026] for (kk in seq_along(NAMES)) {
[16:20:27.026] name <- removed[[kk]]
[16:20:27.026] NAME <- NAMES[[kk]]
[16:20:27.026] if (name != NAME && is.element(NAME, old_names))
[16:20:27.026] next
[16:20:27.026] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:27.026] }
[16:20:27.026] if (length(args) > 0)
[16:20:27.026] base::do.call(base::Sys.setenv, args = args)
[16:20:27.026] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[16:20:27.026] }
[16:20:27.026] else {
[16:20:27.026] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[16:20:27.026] }
[16:20:27.026] {
[16:20:27.026] if (base::length(...future.futureOptionsAdded) >
[16:20:27.026] 0L) {
[16:20:27.026] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[16:20:27.026] base::names(opts) <- ...future.futureOptionsAdded
[16:20:27.026] base::options(opts)
[16:20:27.026] }
[16:20:27.026] {
[16:20:27.026] NULL
[16:20:27.026] options(future.plan = NULL)
[16:20:27.026] if (is.na(NA_character_))
[16:20:27.026] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:27.026] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[16:20:27.026] future::plan(...future.strategy.old, .cleanup = FALSE,
[16:20:27.026] .init = FALSE)
[16:20:27.026] }
[16:20:27.026] }
[16:20:27.026] }
[16:20:27.026] })
[16:20:27.026] if (TRUE) {
[16:20:27.026] base::sink(type = "output", split = FALSE)
[16:20:27.026] if (TRUE) {
[16:20:27.026] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[16:20:27.026] }
[16:20:27.026] else {
[16:20:27.026] ...future.result["stdout"] <- base::list(NULL)
[16:20:27.026] }
[16:20:27.026] base::close(...future.stdout)
[16:20:27.026] ...future.stdout <- NULL
[16:20:27.026] }
[16:20:27.026] ...future.result$conditions <- ...future.conditions
[16:20:27.026] ...future.result$finished <- base::Sys.time()
[16:20:27.026] ...future.result
[16:20:27.026] }
[16:20:27.033] - Launch lazy future ... done
[16:20:27.034] run() for 'MiraiFuture' ... done
[1] 6
[16:20:27.037] ** Sum function 'B' with plan('mirai_multisession') ...function (x, ...)
{
sumt <- function(x) {
message("Arguments '...' exists: ", exists("...", inherits = TRUE))
y %<-% {
sum(x, ...)
}
y
}
sumt(x)
}
Arguments '...' exists: TRUE
[16:20:27.047] getGlobalsAndPackages() ...
[16:20:27.047] Searching for globals...
[16:20:27.049] - globals found: [4] '{', 'sum', 'x', '...'
[16:20:27.050] Searching for globals ... DONE
[16:20:27.050] Resolving globals: FALSE
[16:20:27.050] Tweak future expression to call with '...' arguments ...
[16:20:27.050] {
[16:20:27.050] do.call(function(...) {
[16:20:27.050] sum(x, ...)
[16:20:27.050] }, args = future.call.arguments)
[16:20:27.050] }
[16:20:27.051] Tweak future expression to call with '...' arguments ... DONE
[16:20:27.052] The total size of the 2 globals is 112 bytes (112 bytes)
[16:20:27.053] The total size of the 2 globals exported for future expression ('{; sum(x, ...); }') is 112 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (56 bytes of class 'numeric') and 'future.call.arguments' (56 bytes of class 'list')
[16:20:27.053] - globals: [2] 'x', 'future.call.arguments'
[16:20:27.053]
[16:20:27.053] getGlobalsAndPackages() ... DONE
[16:20:27.054] run() for 'Future' ...
[16:20:27.054] - state: 'created'
[16:20:27.054] - Future backend: 'FutureStrategy', 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function'
[16:20:27.058] - Future class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[16:20:27.058] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ...
[16:20:27.059] - Field: 'label'
[16:20:27.059] - Field: 'local'
[16:20:27.059] - Field: 'owner'
[16:20:27.059] - Field: 'envir'
[16:20:27.060] - Field: 'packages'
[16:20:27.060] - Field: 'gc'
[16:20:27.060] - Field: 'conditions'
[16:20:27.060] - Field: 'expr'
[16:20:27.061] - Field: 'uuid'
[16:20:27.061] - Field: 'seed'
[16:20:27.061] - Field: 'version'
[16:20:27.061] - Field: 'result'
[16:20:27.062] - Field: 'asynchronous'
[16:20:27.062] - Field: 'calls'
[16:20:27.062] - Field: 'globals'
[16:20:27.062] - Field: 'stdout'
[16:20:27.063] - Field: 'earlySignal'
[16:20:27.063] - Field: 'lazy'
[16:20:27.063] - Field: 'state'
[16:20:27.063] - Field: '.cluster'
[16:20:27.064] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ... done
[16:20:27.064] - Launch lazy future ...
[16:20:27.064] Packages needed by the future expression (n = 0): <none>
[16:20:27.064] Packages needed by future strategies (n = 0): <none>
[16:20:27.065] {
[16:20:27.065] {
[16:20:27.065] {
[16:20:27.065] ...future.startTime <- base::Sys.time()
[16:20:27.065] {
[16:20:27.065] {
[16:20:27.065] {
[16:20:27.065] base::local({
[16:20:27.065] has_future <- base::requireNamespace("future",
[16:20:27.065] quietly = TRUE)
[16:20:27.065] if (has_future) {
[16:20:27.065] ns <- base::getNamespace("future")
[16:20:27.065] version <- ns[[".package"]][["version"]]
[16:20:27.065] if (is.null(version))
[16:20:27.065] version <- utils::packageVersion("future")
[16:20:27.065] }
[16:20:27.065] else {
[16:20:27.065] version <- NULL
[16:20:27.065] }
[16:20:27.065] if (!has_future || version < "1.8.0") {
[16:20:27.065] info <- base::c(r_version = base::gsub("R version ",
[16:20:27.065] "", base::R.version$version.string),
[16:20:27.065] platform = base::sprintf("%s (%s-bit)",
[16:20:27.065] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[16:20:27.065] os = base::paste(base::Sys.info()[base::c("sysname",
[16:20:27.065] "release", "version")], collapse = " "),
[16:20:27.065] hostname = base::Sys.info()[["nodename"]])
[16:20:27.065] info <- base::sprintf("%s: %s", base::names(info),
[16:20:27.065] info)
[16:20:27.065] info <- base::paste(info, collapse = "; ")
[16:20:27.065] if (!has_future) {
[16:20:27.065] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[16:20:27.065] info)
[16:20:27.065] }
[16:20:27.065] else {
[16:20:27.065] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[16:20:27.065] info, version)
[16:20:27.065] }
[16:20:27.065] base::stop(msg)
[16:20:27.065] }
[16:20:27.065] })
[16:20:27.065] }
[16:20:27.065] ...future.strategy.old <- future::plan("list")
[16:20:27.065] options(future.plan = NULL)
[16:20:27.065] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:27.065] future::plan("default", .cleanup = FALSE, .init = FALSE)
[16:20:27.065] }
[16:20:27.065] ...future.workdir <- getwd()
[16:20:27.065] }
[16:20:27.065] ...future.oldOptions <- base::as.list(base::.Options)
[16:20:27.065] ...future.oldEnvVars <- base::Sys.getenv()
[16:20:27.065] }
[16:20:27.065] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[16:20:27.065] future.globals.maxSize = NULL, future.globals.method = NULL,
[16:20:27.065] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[16:20:27.065] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[16:20:27.065] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[16:20:27.065] future.stdout.windows.reencode = NULL, width = 80L)
[16:20:27.065] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[16:20:27.065] base::names(...future.oldOptions))
[16:20:27.065] }
[16:20:27.065] if (FALSE) {
[16:20:27.065] }
[16:20:27.065] else {
[16:20:27.065] if (TRUE) {
[16:20:27.065] ...future.stdout <- base::rawConnection(base::raw(0L),
[16:20:27.065] open = "w")
[16:20:27.065] }
[16:20:27.065] else {
[16:20:27.065] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[16:20:27.065] windows = "NUL", "/dev/null"), open = "w")
[16:20:27.065] }
[16:20:27.065] base::sink(...future.stdout, type = "output", split = FALSE)
[16:20:27.065] base::on.exit(if (!base::is.null(...future.stdout)) {
[16:20:27.065] base::sink(type = "output", split = FALSE)
[16:20:27.065] base::close(...future.stdout)
[16:20:27.065] }, add = TRUE)
[16:20:27.065] }
[16:20:27.065] ...future.frame <- base::sys.nframe()
[16:20:27.065] ...future.conditions <- base::list()
[16:20:27.065] ...future.rng <- base::globalenv()$.Random.seed
[16:20:27.065] if (FALSE) {
[16:20:27.065] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[16:20:27.065] "...future.value", "...future.globalenv.names", ".Random.seed")
[16:20:27.065] }
[16:20:27.065] ...future.result <- base::tryCatch({
[16:20:27.065] base::withCallingHandlers({
[16:20:27.065] ...future.value <- base::withVisible(base::local({
[16:20:27.065] do.call(function(...) {
[16:20:27.065] sum(x, ...)
[16:20:27.065] }, args = future.call.arguments)
[16:20:27.065] }))
[16:20:27.065] future::FutureResult(value = ...future.value$value,
[16:20:27.065] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[16:20:27.065] ...future.rng), globalenv = if (FALSE)
[16:20:27.065] list(added = base::setdiff(base::names(base::.GlobalEnv),
[16:20:27.065] ...future.globalenv.names))
[16:20:27.065] else NULL, started = ...future.startTime, version = "1.8")
[16:20:27.065] }, condition = base::local({
[16:20:27.065] c <- base::c
[16:20:27.065] inherits <- base::inherits
[16:20:27.065] invokeRestart <- base::invokeRestart
[16:20:27.065] length <- base::length
[16:20:27.065] list <- base::list
[16:20:27.065] seq.int <- base::seq.int
[16:20:27.065] signalCondition <- base::signalCondition
[16:20:27.065] sys.calls <- base::sys.calls
[16:20:27.065] `[[` <- base::`[[`
[16:20:27.065] `+` <- base::`+`
[16:20:27.065] `<<-` <- base::`<<-`
[16:20:27.065] sysCalls <- function(calls = sys.calls(), from = 1L) {
[16:20:27.065] calls[seq.int(from = from + 12L, to = length(calls) -
[16:20:27.065] 3L)]
[16:20:27.065] }
[16:20:27.065] function(cond) {
[16:20:27.065] is_error <- inherits(cond, "error")
[16:20:27.065] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[16:20:27.065] NULL)
[16:20:27.065] if (is_error) {
[16:20:27.065] sessionInformation <- function() {
[16:20:27.065] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[16:20:27.065] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[16:20:27.065] search = base::search(), system = base::Sys.info())
[16:20:27.065] }
[16:20:27.065] ...future.conditions[[length(...future.conditions) +
[16:20:27.065] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[16:20:27.065] cond$call), session = sessionInformation(),
[16:20:27.065] timestamp = base::Sys.time(), signaled = 0L)
[16:20:27.065] signalCondition(cond)
[16:20:27.065] }
[16:20:27.065] else if (!ignore && TRUE && inherits(cond, "condition")) {
[16:20:27.065] signal <- FALSE && inherits(cond, character(0))
[16:20:27.065] ...future.conditions[[length(...future.conditions) +
[16:20:27.065] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[16:20:27.065] if (FALSE && !signal) {
[16:20:27.065] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:27.065] {
[16:20:27.065] inherits <- base::inherits
[16:20:27.065] invokeRestart <- base::invokeRestart
[16:20:27.065] is.null <- base::is.null
[16:20:27.065] muffled <- FALSE
[16:20:27.065] if (inherits(cond, "message")) {
[16:20:27.065] muffled <- grepl(pattern, "muffleMessage")
[16:20:27.065] if (muffled)
[16:20:27.065] invokeRestart("muffleMessage")
[16:20:27.065] }
[16:20:27.065] else if (inherits(cond, "warning")) {
[16:20:27.065] muffled <- grepl(pattern, "muffleWarning")
[16:20:27.065] if (muffled)
[16:20:27.065] invokeRestart("muffleWarning")
[16:20:27.065] }
[16:20:27.065] else if (inherits(cond, "condition")) {
[16:20:27.065] if (!is.null(pattern)) {
[16:20:27.065] computeRestarts <- base::computeRestarts
[16:20:27.065] grepl <- base::grepl
[16:20:27.065] restarts <- computeRestarts(cond)
[16:20:27.065] for (restart in restarts) {
[16:20:27.065] name <- restart$name
[16:20:27.065] if (is.null(name))
[16:20:27.065] next
[16:20:27.065] if (!grepl(pattern, name))
[16:20:27.065] next
[16:20:27.065] invokeRestart(restart)
[16:20:27.065] muffled <- TRUE
[16:20:27.065] break
[16:20:27.065] }
[16:20:27.065] }
[16:20:27.065] }
[16:20:27.065] invisible(muffled)
[16:20:27.065] }
[16:20:27.065] muffleCondition(cond, pattern = "^muffle")
[16:20:27.065] }
[16:20:27.065] }
[16:20:27.065] else {
[16:20:27.065] if (TRUE) {
[16:20:27.065] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:27.065] {
[16:20:27.065] inherits <- base::inherits
[16:20:27.065] invokeRestart <- base::invokeRestart
[16:20:27.065] is.null <- base::is.null
[16:20:27.065] muffled <- FALSE
[16:20:27.065] if (inherits(cond, "message")) {
[16:20:27.065] muffled <- grepl(pattern, "muffleMessage")
[16:20:27.065] if (muffled)
[16:20:27.065] invokeRestart("muffleMessage")
[16:20:27.065] }
[16:20:27.065] else if (inherits(cond, "warning")) {
[16:20:27.065] muffled <- grepl(pattern, "muffleWarning")
[16:20:27.065] if (muffled)
[16:20:27.065] invokeRestart("muffleWarning")
[16:20:27.065] }
[16:20:27.065] else if (inherits(cond, "condition")) {
[16:20:27.065] if (!is.null(pattern)) {
[16:20:27.065] computeRestarts <- base::computeRestarts
[16:20:27.065] grepl <- base::grepl
[16:20:27.065] restarts <- computeRestarts(cond)
[16:20:27.065] for (restart in restarts) {
[16:20:27.065] name <- restart$name
[16:20:27.065] if (is.null(name))
[16:20:27.065] next
[16:20:27.065] if (!grepl(pattern, name))
[16:20:27.065] next
[16:20:27.065] invokeRestart(restart)
[16:20:27.065] muffled <- TRUE
[16:20:27.065] break
[16:20:27.065] }
[16:20:27.065] }
[16:20:27.065] }
[16:20:27.065] invisible(muffled)
[16:20:27.065] }
[16:20:27.065] muffleCondition(cond, pattern = "^muffle")
[16:20:27.065] }
[16:20:27.065] }
[16:20:27.065] }
[16:20:27.065] }))
[16:20:27.065] }, error = function(ex) {
[16:20:27.065] base::structure(base::list(value = NULL, visible = NULL,
[16:20:27.065] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[16:20:27.065] ...future.rng), started = ...future.startTime,
[16:20:27.065] finished = Sys.time(), session_uuid = NA_character_,
[16:20:27.065] version = "1.8"), class = "FutureResult")
[16:20:27.065] }, finally = {
[16:20:27.065] if (!identical(...future.workdir, getwd()))
[16:20:27.065] setwd(...future.workdir)
[16:20:27.065] {
[16:20:27.065] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[16:20:27.065] ...future.oldOptions$nwarnings <- NULL
[16:20:27.065] }
[16:20:27.065] base::options(...future.oldOptions)
[16:20:27.065] if (.Platform$OS.type == "windows") {
[16:20:27.065] old_names <- names(...future.oldEnvVars)
[16:20:27.065] envs <- base::Sys.getenv()
[16:20:27.065] names <- names(envs)
[16:20:27.065] common <- intersect(names, old_names)
[16:20:27.065] added <- setdiff(names, old_names)
[16:20:27.065] removed <- setdiff(old_names, names)
[16:20:27.065] changed <- common[...future.oldEnvVars[common] !=
[16:20:27.065] envs[common]]
[16:20:27.065] NAMES <- toupper(changed)
[16:20:27.065] args <- list()
[16:20:27.065] for (kk in seq_along(NAMES)) {
[16:20:27.065] name <- changed[[kk]]
[16:20:27.065] NAME <- NAMES[[kk]]
[16:20:27.065] if (name != NAME && is.element(NAME, old_names))
[16:20:27.065] next
[16:20:27.065] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:27.065] }
[16:20:27.065] NAMES <- toupper(added)
[16:20:27.065] for (kk in seq_along(NAMES)) {
[16:20:27.065] name <- added[[kk]]
[16:20:27.065] NAME <- NAMES[[kk]]
[16:20:27.065] if (name != NAME && is.element(NAME, old_names))
[16:20:27.065] next
[16:20:27.065] args[[name]] <- ""
[16:20:27.065] }
[16:20:27.065] NAMES <- toupper(removed)
[16:20:27.065] for (kk in seq_along(NAMES)) {
[16:20:27.065] name <- removed[[kk]]
[16:20:27.065] NAME <- NAMES[[kk]]
[16:20:27.065] if (name != NAME && is.element(NAME, old_names))
[16:20:27.065] next
[16:20:27.065] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:27.065] }
[16:20:27.065] if (length(args) > 0)
[16:20:27.065] base::do.call(base::Sys.setenv, args = args)
[16:20:27.065] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[16:20:27.065] }
[16:20:27.065] else {
[16:20:27.065] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[16:20:27.065] }
[16:20:27.065] {
[16:20:27.065] if (base::length(...future.futureOptionsAdded) >
[16:20:27.065] 0L) {
[16:20:27.065] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[16:20:27.065] base::names(opts) <- ...future.futureOptionsAdded
[16:20:27.065] base::options(opts)
[16:20:27.065] }
[16:20:27.065] {
[16:20:27.065] NULL
[16:20:27.065] options(future.plan = NULL)
[16:20:27.065] if (is.na(NA_character_))
[16:20:27.065] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:27.065] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[16:20:27.065] future::plan(...future.strategy.old, .cleanup = FALSE,
[16:20:27.065] .init = FALSE)
[16:20:27.065] }
[16:20:27.065] }
[16:20:27.065] }
[16:20:27.065] })
[16:20:27.065] if (TRUE) {
[16:20:27.065] base::sink(type = "output", split = FALSE)
[16:20:27.065] if (TRUE) {
[16:20:27.065] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[16:20:27.065] }
[16:20:27.065] else {
[16:20:27.065] ...future.result["stdout"] <- base::list(NULL)
[16:20:27.065] }
[16:20:27.065] base::close(...future.stdout)
[16:20:27.065] ...future.stdout <- NULL
[16:20:27.065] }
[16:20:27.065] ...future.result$conditions <- ...future.conditions
[16:20:27.065] ...future.result$finished <- base::Sys.time()
[16:20:27.065] ...future.result
[16:20:27.065] }
[16:20:27.071] - Launch lazy future ... done
[16:20:27.071] run() for 'MiraiFuture' ... done
[1] 6
[16:20:27.075] ** Sum function 'C' with plan('mirai_multisession') ...function (x, y)
{
message("Arguments '...' exists: ", exists("...", inherits = TRUE))
y %<-% {
sum(x, y)
}
y
}
Arguments '...' exists: FALSE
[16:20:27.082] getGlobalsAndPackages() ...
[16:20:27.082] Searching for globals...
[16:20:27.085] - globals found: [4] '{', 'sum', 'x', 'y'
[16:20:27.086] Searching for globals ... DONE
[16:20:27.086] Resolving globals: FALSE
[16:20:27.087] The total size of the 2 globals is 112 bytes (112 bytes)
[16:20:27.088] The total size of the 2 globals exported for future expression ('{; sum(x, y); }') is 112 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (56 bytes of class 'numeric') and 'y' (56 bytes of class 'numeric')
[16:20:27.088] - globals: [2] 'x', 'y'
[16:20:27.089]
[16:20:27.089] getGlobalsAndPackages() ... DONE
[16:20:27.090] run() for 'Future' ...
[16:20:27.090] - state: 'created'
[16:20:27.090] - Future backend: 'FutureStrategy', 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function'
[16:20:27.096] - Future class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[16:20:27.097] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ...
[16:20:27.097] - Field: 'label'
[16:20:27.098] - Field: 'local'
[16:20:27.098] - Field: 'owner'
[16:20:27.098] - Field: 'envir'
[16:20:27.099] - Field: 'packages'
[16:20:27.099] - Field: 'gc'
[16:20:27.099] - Field: 'conditions'
[16:20:27.100] - Field: 'expr'
[16:20:27.100] - Field: 'uuid'
[16:20:27.100] - Field: 'seed'
[16:20:27.101] - Field: 'version'
[16:20:27.101] - Field: 'result'
[16:20:27.102] - Field: 'asynchronous'
[16:20:27.102] - Field: 'calls'
[16:20:27.102] - Field: 'globals'
[16:20:27.103] - Field: 'stdout'
[16:20:27.103] - Field: 'earlySignal'
[16:20:27.103] - Field: 'lazy'
[16:20:27.104] - Field: 'state'
[16:20:27.104] - Field: '.cluster'
[16:20:27.105] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ... done
[16:20:27.105] - Launch lazy future ...
[16:20:27.105] Packages needed by the future expression (n = 0): <none>
[16:20:27.106] Packages needed by future strategies (n = 0): <none>
[16:20:27.107] {
[16:20:27.107] {
[16:20:27.107] {
[16:20:27.107] ...future.startTime <- base::Sys.time()
[16:20:27.107] {
[16:20:27.107] {
[16:20:27.107] {
[16:20:27.107] base::local({
[16:20:27.107] has_future <- base::requireNamespace("future",
[16:20:27.107] quietly = TRUE)
[16:20:27.107] if (has_future) {
[16:20:27.107] ns <- base::getNamespace("future")
[16:20:27.107] version <- ns[[".package"]][["version"]]
[16:20:27.107] if (is.null(version))
[16:20:27.107] version <- utils::packageVersion("future")
[16:20:27.107] }
[16:20:27.107] else {
[16:20:27.107] version <- NULL
[16:20:27.107] }
[16:20:27.107] if (!has_future || version < "1.8.0") {
[16:20:27.107] info <- base::c(r_version = base::gsub("R version ",
[16:20:27.107] "", base::R.version$version.string),
[16:20:27.107] platform = base::sprintf("%s (%s-bit)",
[16:20:27.107] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[16:20:27.107] os = base::paste(base::Sys.info()[base::c("sysname",
[16:20:27.107] "release", "version")], collapse = " "),
[16:20:27.107] hostname = base::Sys.info()[["nodename"]])
[16:20:27.107] info <- base::sprintf("%s: %s", base::names(info),
[16:20:27.107] info)
[16:20:27.107] info <- base::paste(info, collapse = "; ")
[16:20:27.107] if (!has_future) {
[16:20:27.107] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[16:20:27.107] info)
[16:20:27.107] }
[16:20:27.107] else {
[16:20:27.107] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[16:20:27.107] info, version)
[16:20:27.107] }
[16:20:27.107] base::stop(msg)
[16:20:27.107] }
[16:20:27.107] })
[16:20:27.107] }
[16:20:27.107] ...future.strategy.old <- future::plan("list")
[16:20:27.107] options(future.plan = NULL)
[16:20:27.107] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:27.107] future::plan("default", .cleanup = FALSE, .init = FALSE)
[16:20:27.107] }
[16:20:27.107] ...future.workdir <- getwd()
[16:20:27.107] }
[16:20:27.107] ...future.oldOptions <- base::as.list(base::.Options)
[16:20:27.107] ...future.oldEnvVars <- base::Sys.getenv()
[16:20:27.107] }
[16:20:27.107] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[16:20:27.107] future.globals.maxSize = NULL, future.globals.method = NULL,
[16:20:27.107] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[16:20:27.107] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[16:20:27.107] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[16:20:27.107] future.stdout.windows.reencode = NULL, width = 80L)
[16:20:27.107] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[16:20:27.107] base::names(...future.oldOptions))
[16:20:27.107] }
[16:20:27.107] if (FALSE) {
[16:20:27.107] }
[16:20:27.107] else {
[16:20:27.107] if (TRUE) {
[16:20:27.107] ...future.stdout <- base::rawConnection(base::raw(0L),
[16:20:27.107] open = "w")
[16:20:27.107] }
[16:20:27.107] else {
[16:20:27.107] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[16:20:27.107] windows = "NUL", "/dev/null"), open = "w")
[16:20:27.107] }
[16:20:27.107] base::sink(...future.stdout, type = "output", split = FALSE)
[16:20:27.107] base::on.exit(if (!base::is.null(...future.stdout)) {
[16:20:27.107] base::sink(type = "output", split = FALSE)
[16:20:27.107] base::close(...future.stdout)
[16:20:27.107] }, add = TRUE)
[16:20:27.107] }
[16:20:27.107] ...future.frame <- base::sys.nframe()
[16:20:27.107] ...future.conditions <- base::list()
[16:20:27.107] ...future.rng <- base::globalenv()$.Random.seed
[16:20:27.107] if (FALSE) {
[16:20:27.107] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[16:20:27.107] "...future.value", "...future.globalenv.names", ".Random.seed")
[16:20:27.107] }
[16:20:27.107] ...future.result <- base::tryCatch({
[16:20:27.107] base::withCallingHandlers({
[16:20:27.107] ...future.value <- base::withVisible(base::local({
[16:20:27.107] sum(x, y)
[16:20:27.107] }))
[16:20:27.107] future::FutureResult(value = ...future.value$value,
[16:20:27.107] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[16:20:27.107] ...future.rng), globalenv = if (FALSE)
[16:20:27.107] list(added = base::setdiff(base::names(base::.GlobalEnv),
[16:20:27.107] ...future.globalenv.names))
[16:20:27.107] else NULL, started = ...future.startTime, version = "1.8")
[16:20:27.107] }, condition = base::local({
[16:20:27.107] c <- base::c
[16:20:27.107] inherits <- base::inherits
[16:20:27.107] invokeRestart <- base::invokeRestart
[16:20:27.107] length <- base::length
[16:20:27.107] list <- base::list
[16:20:27.107] seq.int <- base::seq.int
[16:20:27.107] signalCondition <- base::signalCondition
[16:20:27.107] sys.calls <- base::sys.calls
[16:20:27.107] `[[` <- base::`[[`
[16:20:27.107] `+` <- base::`+`
[16:20:27.107] `<<-` <- base::`<<-`
[16:20:27.107] sysCalls <- function(calls = sys.calls(), from = 1L) {
[16:20:27.107] calls[seq.int(from = from + 12L, to = length(calls) -
[16:20:27.107] 3L)]
[16:20:27.107] }
[16:20:27.107] function(cond) {
[16:20:27.107] is_error <- inherits(cond, "error")
[16:20:27.107] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[16:20:27.107] NULL)
[16:20:27.107] if (is_error) {
[16:20:27.107] sessionInformation <- function() {
[16:20:27.107] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[16:20:27.107] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[16:20:27.107] search = base::search(), system = base::Sys.info())
[16:20:27.107] }
[16:20:27.107] ...future.conditions[[length(...future.conditions) +
[16:20:27.107] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[16:20:27.107] cond$call), session = sessionInformation(),
[16:20:27.107] timestamp = base::Sys.time(), signaled = 0L)
[16:20:27.107] signalCondition(cond)
[16:20:27.107] }
[16:20:27.107] else if (!ignore && TRUE && inherits(cond, "condition")) {
[16:20:27.107] signal <- FALSE && inherits(cond, character(0))
[16:20:27.107] ...future.conditions[[length(...future.conditions) +
[16:20:27.107] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[16:20:27.107] if (FALSE && !signal) {
[16:20:27.107] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:27.107] {
[16:20:27.107] inherits <- base::inherits
[16:20:27.107] invokeRestart <- base::invokeRestart
[16:20:27.107] is.null <- base::is.null
[16:20:27.107] muffled <- FALSE
[16:20:27.107] if (inherits(cond, "message")) {
[16:20:27.107] muffled <- grepl(pattern, "muffleMessage")
[16:20:27.107] if (muffled)
[16:20:27.107] invokeRestart("muffleMessage")
[16:20:27.107] }
[16:20:27.107] else if (inherits(cond, "warning")) {
[16:20:27.107] muffled <- grepl(pattern, "muffleWarning")
[16:20:27.107] if (muffled)
[16:20:27.107] invokeRestart("muffleWarning")
[16:20:27.107] }
[16:20:27.107] else if (inherits(cond, "condition")) {
[16:20:27.107] if (!is.null(pattern)) {
[16:20:27.107] computeRestarts <- base::computeRestarts
[16:20:27.107] grepl <- base::grepl
[16:20:27.107] restarts <- computeRestarts(cond)
[16:20:27.107] for (restart in restarts) {
[16:20:27.107] name <- restart$name
[16:20:27.107] if (is.null(name))
[16:20:27.107] next
[16:20:27.107] if (!grepl(pattern, name))
[16:20:27.107] next
[16:20:27.107] invokeRestart(restart)
[16:20:27.107] muffled <- TRUE
[16:20:27.107] break
[16:20:27.107] }
[16:20:27.107] }
[16:20:27.107] }
[16:20:27.107] invisible(muffled)
[16:20:27.107] }
[16:20:27.107] muffleCondition(cond, pattern = "^muffle")
[16:20:27.107] }
[16:20:27.107] }
[16:20:27.107] else {
[16:20:27.107] if (TRUE) {
[16:20:27.107] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:27.107] {
[16:20:27.107] inherits <- base::inherits
[16:20:27.107] invokeRestart <- base::invokeRestart
[16:20:27.107] is.null <- base::is.null
[16:20:27.107] muffled <- FALSE
[16:20:27.107] if (inherits(cond, "message")) {
[16:20:27.107] muffled <- grepl(pattern, "muffleMessage")
[16:20:27.107] if (muffled)
[16:20:27.107] invokeRestart("muffleMessage")
[16:20:27.107] }
[16:20:27.107] else if (inherits(cond, "warning")) {
[16:20:27.107] muffled <- grepl(pattern, "muffleWarning")
[16:20:27.107] if (muffled)
[16:20:27.107] invokeRestart("muffleWarning")
[16:20:27.107] }
[16:20:27.107] else if (inherits(cond, "condition")) {
[16:20:27.107] if (!is.null(pattern)) {
[16:20:27.107] computeRestarts <- base::computeRestarts
[16:20:27.107] grepl <- base::grepl
[16:20:27.107] restarts <- computeRestarts(cond)
[16:20:27.107] for (restart in restarts) {
[16:20:27.107] name <- restart$name
[16:20:27.107] if (is.null(name))
[16:20:27.107] next
[16:20:27.107] if (!grepl(pattern, name))
[16:20:27.107] next
[16:20:27.107] invokeRestart(restart)
[16:20:27.107] muffled <- TRUE
[16:20:27.107] break
[16:20:27.107] }
[16:20:27.107] }
[16:20:27.107] }
[16:20:27.107] invisible(muffled)
[16:20:27.107] }
[16:20:27.107] muffleCondition(cond, pattern = "^muffle")
[16:20:27.107] }
[16:20:27.107] }
[16:20:27.107] }
[16:20:27.107] }))
[16:20:27.107] }, error = function(ex) {
[16:20:27.107] base::structure(base::list(value = NULL, visible = NULL,
[16:20:27.107] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[16:20:27.107] ...future.rng), started = ...future.startTime,
[16:20:27.107] finished = Sys.time(), session_uuid = NA_character_,
[16:20:27.107] version = "1.8"), class = "FutureResult")
[16:20:27.107] }, finally = {
[16:20:27.107] if (!identical(...future.workdir, getwd()))
[16:20:27.107] setwd(...future.workdir)
[16:20:27.107] {
[16:20:27.107] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[16:20:27.107] ...future.oldOptions$nwarnings <- NULL
[16:20:27.107] }
[16:20:27.107] base::options(...future.oldOptions)
[16:20:27.107] if (.Platform$OS.type == "windows") {
[16:20:27.107] old_names <- names(...future.oldEnvVars)
[16:20:27.107] envs <- base::Sys.getenv()
[16:20:27.107] names <- names(envs)
[16:20:27.107] common <- intersect(names, old_names)
[16:20:27.107] added <- setdiff(names, old_names)
[16:20:27.107] removed <- setdiff(old_names, names)
[16:20:27.107] changed <- common[...future.oldEnvVars[common] !=
[16:20:27.107] envs[common]]
[16:20:27.107] NAMES <- toupper(changed)
[16:20:27.107] args <- list()
[16:20:27.107] for (kk in seq_along(NAMES)) {
[16:20:27.107] name <- changed[[kk]]
[16:20:27.107] NAME <- NAMES[[kk]]
[16:20:27.107] if (name != NAME && is.element(NAME, old_names))
[16:20:27.107] next
[16:20:27.107] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:27.107] }
[16:20:27.107] NAMES <- toupper(added)
[16:20:27.107] for (kk in seq_along(NAMES)) {
[16:20:27.107] name <- added[[kk]]
[16:20:27.107] NAME <- NAMES[[kk]]
[16:20:27.107] if (name != NAME && is.element(NAME, old_names))
[16:20:27.107] next
[16:20:27.107] args[[name]] <- ""
[16:20:27.107] }
[16:20:27.107] NAMES <- toupper(removed)
[16:20:27.107] for (kk in seq_along(NAMES)) {
[16:20:27.107] name <- removed[[kk]]
[16:20:27.107] NAME <- NAMES[[kk]]
[16:20:27.107] if (name != NAME && is.element(NAME, old_names))
[16:20:27.107] next
[16:20:27.107] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:27.107] }
[16:20:27.107] if (length(args) > 0)
[16:20:27.107] base::do.call(base::Sys.setenv, args = args)
[16:20:27.107] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[16:20:27.107] }
[16:20:27.107] else {
[16:20:27.107] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[16:20:27.107] }
[16:20:27.107] {
[16:20:27.107] if (base::length(...future.futureOptionsAdded) >
[16:20:27.107] 0L) {
[16:20:27.107] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[16:20:27.107] base::names(opts) <- ...future.futureOptionsAdded
[16:20:27.107] base::options(opts)
[16:20:27.107] }
[16:20:27.107] {
[16:20:27.107] NULL
[16:20:27.107] options(future.plan = NULL)
[16:20:27.107] if (is.na(NA_character_))
[16:20:27.107] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:27.107] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[16:20:27.107] future::plan(...future.strategy.old, .cleanup = FALSE,
[16:20:27.107] .init = FALSE)
[16:20:27.107] }
[16:20:27.107] }
[16:20:27.107] }
[16:20:27.107] })
[16:20:27.107] if (TRUE) {
[16:20:27.107] base::sink(type = "output", split = FALSE)
[16:20:27.107] if (TRUE) {
[16:20:27.107] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[16:20:27.107] }
[16:20:27.107] else {
[16:20:27.107] ...future.result["stdout"] <- base::list(NULL)
[16:20:27.107] }
[16:20:27.107] base::close(...future.stdout)
[16:20:27.107] ...future.stdout <- NULL
[16:20:27.107] }
[16:20:27.107] ...future.result$conditions <- ...future.conditions
[16:20:27.107] ...future.result$finished <- base::Sys.time()
[16:20:27.107] ...future.result
[16:20:27.107] }
[16:20:27.120] - Launch lazy future ... done
[16:20:27.120] run() for 'MiraiFuture' ... done
[1] 6
[16:20:27.126] ** Sum function 'D' with plan('mirai_multisession') ...function (x, y)
{
message("Arguments '...' exists: ", exists("...", inherits = TRUE))
y %<-% {
sum(x, y, ...)
}
y
}
Arguments '...' exists: FALSE
[16:20:27.133] getGlobalsAndPackages() ...
[16:20:27.134] Searching for globals...
[16:20:27.137] - globals found: [5] '{', 'sum', 'x', 'y', '...'
[16:20:27.138] Searching for globals ... DONE
[16:20:27.138] Resolving globals: FALSE
[16:20:27.138] Tweak future expression to call with '...' arguments ...
[16:20:27.140] The total size of the 2 globals is 112 bytes (112 bytes)
[16:20:27.140] The total size of the 2 globals exported for future expression ('{; sum(x, y, ...); }') is 112 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (56 bytes of class 'numeric') and 'y' (56 bytes of class 'numeric')
[16:20:27.141] - globals: [2] 'x', 'y'
[16:20:27.141]
[16:20:27.141] getGlobalsAndPackages() ... DONE
[16:20:27.142] run() for 'Future' ...
[16:20:27.142] - state: 'created'
[16:20:27.143] - Future backend: 'FutureStrategy', 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function'
[16:20:27.148] - Future class: 'MiraiFuture', 'MultiprocessFuture', 'Future', 'environment'
[16:20:27.148] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ...
[16:20:27.148] - Field: 'label'
[16:20:27.149] - Field: 'local'
[16:20:27.149] - Field: 'owner'
[16:20:27.149] - Field: 'envir'
[16:20:27.150] - Field: 'packages'
[16:20:27.150] - Field: 'gc'
[16:20:27.150] - Field: 'conditions'
[16:20:27.151] - Field: 'expr'
[16:20:27.151] - Field: 'uuid'
[16:20:27.151] - Field: 'seed'
[16:20:27.152] - Field: 'version'
[16:20:27.152] - Field: 'result'
[16:20:27.152] - Field: 'asynchronous'
[16:20:27.153] - Field: 'calls'
[16:20:27.153] - Field: 'globals'
[16:20:27.153] - Field: 'stdout'
[16:20:27.154] - Field: 'earlySignal'
[16:20:27.154] - Field: 'lazy'
[16:20:27.154] - Field: 'state'
[16:20:27.155] - Field: '.cluster'
[16:20:27.155] - Copy elements of temporary 'MiraiFuture' to final 'Future' object ... done
[16:20:27.155] - Launch lazy future ...
[16:20:27.156] Packages needed by the future expression (n = 0): <none>
[16:20:27.156] Packages needed by future strategies (n = 0): <none>
[16:20:27.157] {
[16:20:27.157] {
[16:20:27.157] {
[16:20:27.157] ...future.startTime <- base::Sys.time()
[16:20:27.157] {
[16:20:27.157] {
[16:20:27.157] {
[16:20:27.157] base::local({
[16:20:27.157] has_future <- base::requireNamespace("future",
[16:20:27.157] quietly = TRUE)
[16:20:27.157] if (has_future) {
[16:20:27.157] ns <- base::getNamespace("future")
[16:20:27.157] version <- ns[[".package"]][["version"]]
[16:20:27.157] if (is.null(version))
[16:20:27.157] version <- utils::packageVersion("future")
[16:20:27.157] }
[16:20:27.157] else {
[16:20:27.157] version <- NULL
[16:20:27.157] }
[16:20:27.157] if (!has_future || version < "1.8.0") {
[16:20:27.157] info <- base::c(r_version = base::gsub("R version ",
[16:20:27.157] "", base::R.version$version.string),
[16:20:27.157] platform = base::sprintf("%s (%s-bit)",
[16:20:27.157] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
[16:20:27.157] os = base::paste(base::Sys.info()[base::c("sysname",
[16:20:27.157] "release", "version")], collapse = " "),
[16:20:27.157] hostname = base::Sys.info()[["nodename"]])
[16:20:27.157] info <- base::sprintf("%s: %s", base::names(info),
[16:20:27.157] info)
[16:20:27.157] info <- base::paste(info, collapse = "; ")
[16:20:27.157] if (!has_future) {
[16:20:27.157] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
[16:20:27.157] info)
[16:20:27.157] }
[16:20:27.157] else {
[16:20:27.157] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
[16:20:27.157] info, version)
[16:20:27.157] }
[16:20:27.157] base::stop(msg)
[16:20:27.157] }
[16:20:27.157] })
[16:20:27.157] }
[16:20:27.157] ...future.strategy.old <- future::plan("list")
[16:20:27.157] options(future.plan = NULL)
[16:20:27.157] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:27.157] future::plan("default", .cleanup = FALSE, .init = FALSE)
[16:20:27.157] }
[16:20:27.157] ...future.workdir <- getwd()
[16:20:27.157] }
[16:20:27.157] ...future.oldOptions <- base::as.list(base::.Options)
[16:20:27.157] ...future.oldEnvVars <- base::Sys.getenv()
[16:20:27.157] }
[16:20:27.157] base::options(future.startup.script = FALSE, future.globals.onMissing = NULL,
[16:20:27.157] future.globals.maxSize = NULL, future.globals.method = NULL,
[16:20:27.157] future.globals.onMissing = NULL, future.globals.onReference = NULL,
[16:20:27.157] future.globals.resolve = NULL, future.resolve.recursive = NULL,
[16:20:27.157] future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL,
[16:20:27.157] future.stdout.windows.reencode = NULL, width = 80L)
[16:20:27.157] ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options),
[16:20:27.157] base::names(...future.oldOptions))
[16:20:27.157] }
[16:20:27.157] if (FALSE) {
[16:20:27.157] }
[16:20:27.157] else {
[16:20:27.157] if (TRUE) {
[16:20:27.157] ...future.stdout <- base::rawConnection(base::raw(0L),
[16:20:27.157] open = "w")
[16:20:27.157] }
[16:20:27.157] else {
[16:20:27.157] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
[16:20:27.157] windows = "NUL", "/dev/null"), open = "w")
[16:20:27.157] }
[16:20:27.157] base::sink(...future.stdout, type = "output", split = FALSE)
[16:20:27.157] base::on.exit(if (!base::is.null(...future.stdout)) {
[16:20:27.157] base::sink(type = "output", split = FALSE)
[16:20:27.157] base::close(...future.stdout)
[16:20:27.157] }, add = TRUE)
[16:20:27.157] }
[16:20:27.157] ...future.frame <- base::sys.nframe()
[16:20:27.157] ...future.conditions <- base::list()
[16:20:27.157] ...future.rng <- base::globalenv()$.Random.seed
[16:20:27.157] if (FALSE) {
[16:20:27.157] ...future.globalenv.names <- c(base::names(base::.GlobalEnv),
[16:20:27.157] "...future.value", "...future.globalenv.names", ".Random.seed")
[16:20:27.157] }
[16:20:27.157] ...future.result <- base::tryCatch({
[16:20:27.157] base::withCallingHandlers({
[16:20:27.157] ...future.value <- base::withVisible(base::local({
[16:20:27.157] sum(x, y, ...)
[16:20:27.157] }))
[16:20:27.157] future::FutureResult(value = ...future.value$value,
[16:20:27.157] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
[16:20:27.157] ...future.rng), globalenv = if (FALSE)
[16:20:27.157] list(added = base::setdiff(base::names(base::.GlobalEnv),
[16:20:27.157] ...future.globalenv.names))
[16:20:27.157] else NULL, started = ...future.startTime, version = "1.8")
[16:20:27.157] }, condition = base::local({
[16:20:27.157] c <- base::c
[16:20:27.157] inherits <- base::inherits
[16:20:27.157] invokeRestart <- base::invokeRestart
[16:20:27.157] length <- base::length
[16:20:27.157] list <- base::list
[16:20:27.157] seq.int <- base::seq.int
[16:20:27.157] signalCondition <- base::signalCondition
[16:20:27.157] sys.calls <- base::sys.calls
[16:20:27.157] `[[` <- base::`[[`
[16:20:27.157] `+` <- base::`+`
[16:20:27.157] `<<-` <- base::`<<-`
[16:20:27.157] sysCalls <- function(calls = sys.calls(), from = 1L) {
[16:20:27.157] calls[seq.int(from = from + 12L, to = length(calls) -
[16:20:27.157] 3L)]
[16:20:27.157] }
[16:20:27.157] function(cond) {
[16:20:27.157] is_error <- inherits(cond, "error")
[16:20:27.157] ignore <- !is_error && !is.null(NULL) && inherits(cond,
[16:20:27.157] NULL)
[16:20:27.157] if (is_error) {
[16:20:27.157] sessionInformation <- function() {
[16:20:27.157] list(r = base::R.Version(), locale = base::Sys.getlocale(),
[16:20:27.157] rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),
[16:20:27.157] search = base::search(), system = base::Sys.info())
[16:20:27.157] }
[16:20:27.157] ...future.conditions[[length(...future.conditions) +
[16:20:27.157] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
[16:20:27.157] cond$call), session = sessionInformation(),
[16:20:27.157] timestamp = base::Sys.time(), signaled = 0L)
[16:20:27.157] signalCondition(cond)
[16:20:27.157] }
[16:20:27.157] else if (!ignore && TRUE && inherits(cond, "condition")) {
[16:20:27.157] signal <- FALSE && inherits(cond, character(0))
[16:20:27.157] ...future.conditions[[length(...future.conditions) +
[16:20:27.157] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[16:20:27.157] if (FALSE && !signal) {
[16:20:27.157] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:27.157] {
[16:20:27.157] inherits <- base::inherits
[16:20:27.157] invokeRestart <- base::invokeRestart
[16:20:27.157] is.null <- base::is.null
[16:20:27.157] muffled <- FALSE
[16:20:27.157] if (inherits(cond, "message")) {
[16:20:27.157] muffled <- grepl(pattern, "muffleMessage")
[16:20:27.157] if (muffled)
[16:20:27.157] invokeRestart("muffleMessage")
[16:20:27.157] }
[16:20:27.157] else if (inherits(cond, "warning")) {
[16:20:27.157] muffled <- grepl(pattern, "muffleWarning")
[16:20:27.157] if (muffled)
[16:20:27.157] invokeRestart("muffleWarning")
[16:20:27.157] }
[16:20:27.157] else if (inherits(cond, "condition")) {
[16:20:27.157] if (!is.null(pattern)) {
[16:20:27.157] computeRestarts <- base::computeRestarts
[16:20:27.157] grepl <- base::grepl
[16:20:27.157] restarts <- computeRestarts(cond)
[16:20:27.157] for (restart in restarts) {
[16:20:27.157] name <- restart$name
[16:20:27.157] if (is.null(name))
[16:20:27.157] next
[16:20:27.157] if (!grepl(pattern, name))
[16:20:27.157] next
[16:20:27.157] invokeRestart(restart)
[16:20:27.157] muffled <- TRUE
[16:20:27.157] break
[16:20:27.157] }
[16:20:27.157] }
[16:20:27.157] }
[16:20:27.157] invisible(muffled)
[16:20:27.157] }
[16:20:27.157] muffleCondition(cond, pattern = "^muffle")
[16:20:27.157] }
[16:20:27.157] }
[16:20:27.157] else {
[16:20:27.157] if (TRUE) {
[16:20:27.157] muffleCondition <- function (cond, pattern = "^muffle")
[16:20:27.157] {
[16:20:27.157] inherits <- base::inherits
[16:20:27.157] invokeRestart <- base::invokeRestart
[16:20:27.157] is.null <- base::is.null
[16:20:27.157] muffled <- FALSE
[16:20:27.157] if (inherits(cond, "message")) {
[16:20:27.157] muffled <- grepl(pattern, "muffleMessage")
[16:20:27.157] if (muffled)
[16:20:27.157] invokeRestart("muffleMessage")
[16:20:27.157] }
[16:20:27.157] else if (inherits(cond, "warning")) {
[16:20:27.157] muffled <- grepl(pattern, "muffleWarning")
[16:20:27.157] if (muffled)
[16:20:27.157] invokeRestart("muffleWarning")
[16:20:27.157] }
[16:20:27.157] else if (inherits(cond, "condition")) {
[16:20:27.157] if (!is.null(pattern)) {
[16:20:27.157] computeRestarts <- base::computeRestarts
[16:20:27.157] grepl <- base::grepl
[16:20:27.157] restarts <- computeRestarts(cond)
[16:20:27.157] for (restart in restarts) {
[16:20:27.157] name <- restart$name
[16:20:27.157] if (is.null(name))
[16:20:27.157] next
[16:20:27.157] if (!grepl(pattern, name))
[16:20:27.157] next
[16:20:27.157] invokeRestart(restart)
[16:20:27.157] muffled <- TRUE
[16:20:27.157] break
[16:20:27.157] }
[16:20:27.157] }
[16:20:27.157] }
[16:20:27.157] invisible(muffled)
[16:20:27.157] }
[16:20:27.157] muffleCondition(cond, pattern = "^muffle")
[16:20:27.157] }
[16:20:27.157] }
[16:20:27.157] }
[16:20:27.157] }))
[16:20:27.157] }, error = function(ex) {
[16:20:27.157] base::structure(base::list(value = NULL, visible = NULL,
[16:20:27.157] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
[16:20:27.157] ...future.rng), started = ...future.startTime,
[16:20:27.157] finished = Sys.time(), session_uuid = NA_character_,
[16:20:27.157] version = "1.8"), class = "FutureResult")
[16:20:27.157] }, finally = {
[16:20:27.157] if (!identical(...future.workdir, getwd()))
[16:20:27.157] setwd(...future.workdir)
[16:20:27.157] {
[16:20:27.157] if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[16:20:27.157] ...future.oldOptions$nwarnings <- NULL
[16:20:27.157] }
[16:20:27.157] base::options(...future.oldOptions)
[16:20:27.157] if (.Platform$OS.type == "windows") {
[16:20:27.157] old_names <- names(...future.oldEnvVars)
[16:20:27.157] envs <- base::Sys.getenv()
[16:20:27.157] names <- names(envs)
[16:20:27.157] common <- intersect(names, old_names)
[16:20:27.157] added <- setdiff(names, old_names)
[16:20:27.157] removed <- setdiff(old_names, names)
[16:20:27.157] changed <- common[...future.oldEnvVars[common] !=
[16:20:27.157] envs[common]]
[16:20:27.157] NAMES <- toupper(changed)
[16:20:27.157] args <- list()
[16:20:27.157] for (kk in seq_along(NAMES)) {
[16:20:27.157] name <- changed[[kk]]
[16:20:27.157] NAME <- NAMES[[kk]]
[16:20:27.157] if (name != NAME && is.element(NAME, old_names))
[16:20:27.157] next
[16:20:27.157] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:27.157] }
[16:20:27.157] NAMES <- toupper(added)
[16:20:27.157] for (kk in seq_along(NAMES)) {
[16:20:27.157] name <- added[[kk]]
[16:20:27.157] NAME <- NAMES[[kk]]
[16:20:27.157] if (name != NAME && is.element(NAME, old_names))
[16:20:27.157] next
[16:20:27.157] args[[name]] <- ""
[16:20:27.157] }
[16:20:27.157] NAMES <- toupper(removed)
[16:20:27.157] for (kk in seq_along(NAMES)) {
[16:20:27.157] name <- removed[[kk]]
[16:20:27.157] NAME <- NAMES[[kk]]
[16:20:27.157] if (name != NAME && is.element(NAME, old_names))
[16:20:27.157] next
[16:20:27.157] args[[name]] <- ...future.oldEnvVars[[name]]
[16:20:27.157] }
[16:20:27.157] if (length(args) > 0)
[16:20:27.157] base::do.call(base::Sys.setenv, args = args)
[16:20:27.157] args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[16:20:27.157] }
[16:20:27.157] else {
[16:20:27.157] base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[16:20:27.157] }
[16:20:27.157] {
[16:20:27.157] if (base::length(...future.futureOptionsAdded) >
[16:20:27.157] 0L) {
[16:20:27.157] opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[16:20:27.157] base::names(opts) <- ...future.futureOptionsAdded
[16:20:27.157] base::options(opts)
[16:20:27.157] }
[16:20:27.157] {
[16:20:27.157] NULL
[16:20:27.157] options(future.plan = NULL)
[16:20:27.157] if (is.na(NA_character_))
[16:20:27.157] Sys.unsetenv("R_FUTURE_PLAN")
[16:20:27.157] else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[16:20:27.157] future::plan(...future.strategy.old, .cleanup = FALSE,
[16:20:27.157] .init = FALSE)
[16:20:27.157] }
[16:20:27.157] }
[16:20:27.157] }
[16:20:27.157] })
[16:20:27.157] if (TRUE) {
[16:20:27.157] base::sink(type = "output", split = FALSE)
[16:20:27.157] if (TRUE) {
[16:20:27.157] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[16:20:27.157] }
[16:20:27.157] else {
[16:20:27.157] ...future.result["stdout"] <- base::list(NULL)
[16:20:27.157] }
[16:20:27.157] base::close(...future.stdout)
[16:20:27.157] ...future.stdout <- NULL
[16:20:27.157] }
[16:20:27.157] ...future.result$conditions <- ...future.conditions
[16:20:27.157] ...future.result$finished <- base::Sys.time()
[16:20:27.157] ...future.result
[16:20:27.157] }
[16:20:27.169] - Launch lazy future ... done
[16:20:27.170] run() for 'MiraiFuture' ... done
[16:20:27.174] signalConditions() ...
[16:20:27.174] - include = 'immediateCondition'
[16:20:27.175] - exclude =
[16:20:27.175] - resignal = FALSE
[16:20:27.175] - Number of conditions: 1
[16:20:27.175] signalConditions() ... done
[16:20:27.176] Future state: 'finished'
[16:20:27.176] signalConditions() ...
[16:20:27.176] - include = 'condition'
[16:20:27.176] - exclude = 'immediateCondition'
[16:20:27.176] - resignal = TRUE
[16:20:27.177] - Number of conditions: 1
[16:20:27.177] - Condition #1: 'simpleError', 'error', 'condition'
[16:20:27.177] signalConditions() ... done
<simpleError in eval(quote({ sum(x, y, ...)}), new.env()): '...' used in an incorrect context>
>
> message("*** Global argument '...' in futures ... DONE")
*** Global argument '...' in futures ... DONE
>
> source("incl/end.R")
>
> proc.time()
user system elapsed
0.64 0.23 1.68
Flavor: r-release-windows-x86_64
Current CRAN status: OK: 12
Current CRAN status: OK: 13
Current CRAN status: OK: 13
Current CRAN status: OK: 13
Current CRAN status: OK: 13
Current CRAN status: OK: 13
Current CRAN status: ERROR: 1, OK: 11
Version: 0.6.0
Check: re-building of vignette outputs
Result: ERROR
Error(s) in re-building vignettes:
...
--- re-building ‘profmem.md.rsp’ using rsp
R.utils v2.12.3 (2023-11-18 01:00:02 UTC) successfully loaded. See ?R.utils for help.
Attaching package: ‘R.utils’
The following object is masked from ‘package:utils’:
timestamp
The following objects are masked from ‘package:base’:
cat, commandArgs, getOption, isOpen, nullfile, parse, use, warnings
Error: processing vignette 'profmem.md.rsp' failed with diagnostics:
there is no package called ‘microbenchmark’
--- failed re-building ‘profmem.md.rsp’
SUMMARY: processing the following file failed:
‘profmem.md.rsp’
Error: Vignette re-building failed.
Execution halted
Flavor: r-release-macos-arm64
Current CRAN status: OK: 12
Current CRAN status: OK: 13
Current CRAN status: NOTE: 9, OK: 3
Version: 0.16.0
Check: Rd files
Result: NOTE
checkRd: (-1) R.cache-package.Rd:28-30: Lost braces in \itemize; meant \describe ?
checkRd: (-1) R.cache-package.Rd:31-34: Lost braces in \itemize; meant \describe ?
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-devel-windows-x86_64, r-patched-linux-x86_64, r-release-linux-x86_64, r-release-macos-arm64, r-release-windows-x86_64
Current CRAN status: OK: 13
Current CRAN status: OK: 13
Current CRAN status: OK: 13
Current CRAN status: NOTE: 9, OK: 3
Version: 3.7.0
Check: Rd files
Result: NOTE
checkRd: (-1) setOption.Matlab.Rd:37-39: Lost braces in \itemize; meant \describe ?
checkRd: (-1) setOption.Matlab.Rd:40-41: Lost braces in \itemize; meant \describe ?
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-devel-windows-x86_64, r-patched-linux-x86_64, r-release-linux-x86_64, r-release-macos-arm64, r-release-windows-x86_64
Current CRAN status: OK: 12
Current CRAN status: OK: 13
Current CRAN status: OK: 13
Current CRAN status: OK: 12
Current CRAN status: OK: 13
Current CRAN status: OK: 12
Current CRAN status: NOTE: 9, OK: 3
Version: 0.10.1
Check: Rd files
Result: NOTE
checkRd: (-1) TopDom.Rd:21: Lost braces; missing escapes or markup?
21 | Recommended range is in {5, ..., 20}.}
| ^
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-devel-windows-x86_64, r-patched-linux-x86_64, r-release-linux-x86_64, r-release-macos-arm64, r-release-windows-x86_64