CRAN Package Check Results for Package future

Last updated on 2019-03-27 00:47:56 CET.

Flavor Version Tinstall Tcheck Ttotal Status Flags
r-devel-linux-x86_64-debian-clang 1.12.0 6.99 210.52 217.51 OK
r-devel-linux-x86_64-debian-gcc 1.12.0 6.59 169.27 175.86 OK
r-devel-linux-x86_64-fedora-clang 1.12.0 271.87 OK
r-devel-linux-x86_64-fedora-gcc 1.12.0 255.30 OK
r-devel-windows-ix86+x86_64 1.12.0 18.00 375.00 393.00 OK
r-patched-linux-x86_64 1.12.0 6.96 198.83 205.79 ERROR
r-patched-solaris-x86 1.12.0 85.80 OK --no-tests
r-release-linux-x86_64 1.12.0 6.24 202.18 208.42 OK
r-release-windows-ix86+x86_64 1.12.0 13.00 87.00 100.00 ERROR
r-release-osx-x86_64 1.12.0 OK
r-oldrel-windows-ix86+x86_64 1.12.0 9.00 530.00 539.00 OK
r-oldrel-osx-x86_64 1.12.0 OK

Check Details

Version: 1.12.0
Check: tests
Result: ERROR
     Running ‘000.sessionDetails.R’ [6s/7s]
     Running ‘ClusterRegistry.R’ [3s/45s]
     Running ‘Future-class.R’ [1s/15s]
     Running ‘FutureError.R’ [1s/1s]
     Running ‘FutureGlobals.R’ [1s/1s]
     Running ‘FutureRegistry.R’ [1s/1s]
     Running ‘as.cluster.R’ [1s/15s]
     Running ‘availableCores.R’ [1s/1s]
     Running ‘availableWorkers.R’ [1s/1s]
     Running ‘backtrace.R’ [1s/2s]
     Running ‘cluster-missing-future-pkg.R’ [1s/2s]
     Running ‘cluster.R’ [2s/20s]
     Running ‘constant.R’ [1s/1s]
     Running ‘demo.R’ [10s/25s]
     Running ‘dotdotdot.R’ [2s/17s]
     Running ‘early-signaling.R’ [2s/34s]
     Running ‘future,labels.R’ [2s/16s]
     Running ‘future.R’ [1s/1s]
     Running ‘futureAssign.R’ [2s/16s]
     Running ‘futureAssign_OP.R’ [3s/19s]
     Running ‘futureAssign_OP_with_environment.R’ [1s/1s]
     Running ‘futureAssign_OP_with_listenv.R’ [1s/1s]
     Running ‘futureCall.R’ [4s/27s]
     Running ‘futureOf.R’ [1s/1s]
     Running ‘futureOf_with_environment.R’ [1s/1s]
     Running ‘futureOf_with_listenv.R’ [1s/1s]
     Running ‘futures.R’ [16s/124s]
     Running ‘globals,NSE.R’ [2s/30s]
     Running ‘globals,formulas.R’ [4s/19s]
     Running ‘globals,manual.R’ [5s/22s]
     Running ‘globals,resolve.R’ [1s/16s]
     Running ‘globals,subassignment.R’ [3s/18s]
     Running ‘globals,toolarge.R’ [1s/16s]
     Running ‘globals,tricky.R’ [7s/25s]
     Running ‘globals,tricky_recursive.R’ [2s/17s]
     Running ‘globalsOf,tweaks.R’ [1s/1s]
     Running ‘invalid-owner.R’ [2s/17s]
     Running ‘makeClusterPSOCK.R’ [1s/9s]
     Running ‘mandelbrot.R’ [1s/1s]
     Running ‘mpi.R’ [1s/1s]
     Running ‘multicore.R’ [1s/1s]
     Running ‘multiprocess.R’ [1s/2s]
     Running ‘multisession.R’ [4s/52s]
     Running ‘nbrOfWorkers.R’ [5s/80s]
     Running ‘nested_futures,mc.cores.R’ [5s/106s]
     Running ‘nested_futures.R’ [5s/65s]
     Running ‘non-exportable,connections.R’ [1s/17s]
     Running ‘objectSize.R’ [1s/1s]
     Running ‘plan.R’ [5s/14s]
     Running ‘remote.R’ [1s/16s]
     Running ‘requestCore.R’ [1s/3s]
     Running ‘requestNode.R’ [2s/28s]
     Running ‘resolve.R’ [6s/45s]
     Running ‘rng.R’ [6s/23s]
     Running ‘sequential.R’ [1s/1s]
     Running ‘sessionDetails.R’ [1s/1s]
     Running ‘startup.R’ [2s/30s]
     Running ‘stdout.R’ [2s/19s]
     Running ‘transparent.R’ [1s/1s]
     Running ‘tweak.R’ [1s/1s]
     Running ‘utils.R’ [6s/7s]
     Running ‘uuid.R’ [1s/1s]
     Running ‘whichIndex.R’ [1s/1s]
    Running the tests in ‘tests/cluster.R’ failed.
    Complete output:
     > source("incl/start.R")
     plan(): Setting new future strategy stack:
     List of future strategies:
     1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: future::plan("sequential")
    
     plan(): nbrOfWorkers() = 1
     > library("listenv")
     > options(future.debug = FALSE)
     > message("*** cluster() ...")
     *** cluster() ...
     >
     > message("Library paths: ", paste(sQuote(.libPaths()), collapse = ", "))
     Library paths: '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/Packages', '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/library'
     > message("Package path: ", sQuote(system.file(package = "future")))
     Package path: '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/Packages/future'
     >
     > types <- "PSOCK"
     >
     > ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
     > if (isWin32) types <- NULL
     >
     > if (supportsMulticore() && !on_solaris) types <- c(types, "FORK")
     >
     > ## WORKAROUND: covr::package_coverage() -> merge_coverage() -> ... produces
     > ## "Error in readRDS(x) : error reading from connection" for type = "FORK".
     > ## Is this related to mcparallel() comments in help("package_coverage")?
     > ## /HB 2017-05-20
     > if (covr_testing) types <- setdiff(types, "FORK")
     >
     > pid <- Sys.getpid()
     > message("Main PID (original): ", pid)
     Main PID (original): 24724
     > cl <- NULL
     > for (type in types) {
     + message(sprintf("Test set #1 with cluster type %s ...", sQuote(type)))
     +
     + for (cores in 1:availCores) {
     + message(sprintf("Testing with %d cores on type = %s ...",
     + cores, sQuote(type)))
     + options(mc.cores = cores)
     +
     + ## Set up a cluster with <cores> nodes (explicitly)
     + cl <- parallel::makeCluster(cores, type = type, timeout = 60)
     + print(cl)
     +
     + plan(cluster, workers = cl)
     +
     + ## No global variables
     + f <- try(cluster({
     + 42L
     + }, workers = cl), silent = FALSE)
     + print(f)
     + stopifnot(inherits(f, "ClusterFuture"))
     +
     + print(resolved(f))
     + y <- value(f)
     + print(y)
     + stopifnot(y == 42L)
     +
     +
     + ## Set up a cluster with <cores> nodes (implicitly)
     + plan(cluster, workers = cores)
     +
     + ## No global variables
     + f <- try(cluster({
     + 42L
     + }, workers = cl), silent = FALSE)
     + print(f)
     + stopifnot(inherits(f, "ClusterFuture"))
     +
     + print(resolved(f))
     + y <- value(f)
     + print(y)
     + stopifnot(y == 42L)
     +
     +
     + ## A global variable
     + a <- 0
     + f <- try(future({
     + b <- 3
     + c <- 2
     + a * b * c
     + }))
     + print(f)
     +
     +
     + ## A cluster future is evaluated in a separate
     + ## R session process. Changing the value of a global
     + ## variable should not affect the result of the
     + ## future.
     + a <- 7 ## Make sure globals are frozen
     + v <- value(f)
     + print(v)
     + stopifnot(v == 0)
     +
     +
     + message("*** cluster() with globals and blocking")
     + x <- listenv()
     + for (ii in 1:3) {
     + message(sprintf(" - Creating cluster future #%d ...", ii))
     + x[[ii]] <- future({ ii })
     + }
     + message(sprintf(" - Resolving %d cluster futures", length(x)))
     + v <- sapply(x, FUN = value)
     + stopifnot(all(v == 1:3))
     +
     +
     + message("*** cluster() and errors")
     + f <- future({
     + stop("Whoops!")
     + 1
     + })
     + print(f)
     + v <- value(f, signal = FALSE)
     + print(v)
     + stopifnot(inherits(v, "simpleError"))
     +
     + res <- tryCatch(value(f), error = identity)
     + print(res)
     + stopifnot(inherits(res, "error"))
     +
     + ## Error is repeated
     + res <- tryCatch(value(f), error = identity)
     + print(res)
     + stopifnot(inherits(res, "error"))
     +
     + ## Custom error class
     + f <- future({
     + stop(structure(list(message = "boom"),
     + class = c("MyError", "error", "condition")))
     + })
     + print(f)
     + v <- value(f, signal = FALSE)
     + print(v)
     + stopifnot(inherits(v, "error"))
     + ## FIXME: Related to Issue #200
     + ## https://github.com/HenrikBengtsson/Wishlist-for-R/issues/57
     + ## stopifnot(inherits(v, "MyError"))
     +
     + ## Make sure error is signaled
     + res <- tryCatch(value(f), error = identity)
     + stopifnot(inherits(res, "error"))
     +
     + ## Issue #200: Custom condition class attributes are lost
     + ## https://github.com/HenrikBengtsson/Wishlist-for-R/issues/57
     + ## FIXME:
     + ## stopifnot(inherits(res, "MyError"))
     +
     + message("*** cluster() - too large globals ...")
     + ooptsT <- options(future.globals.maxSize = object.size(1:1014))
     +
     + limit <- getOption("future.globals.maxSize")
     + cat(sprintf("Max total size of globals: %g bytes\n", limit))
     +
     + ## A large object
     + a <- 1:1014
     + yTruth <- sum(a)
     + size <- object.size(a)
     + cat(sprintf("a: %g bytes\n", size))
     + f <- future({ sum(a) })
     + print(f)
     + rm(list = "a")
     + v <- value(f)
     + print(v)
     + stopifnot(v == yTruth)
     +
     +
     + ## A too large object
     + a <- 1:1015
     + yTruth <- sum(a)
     + size <- object.size(a)
     + cat(sprintf("a: %g bytes\n", size))
     + res <- tryCatch(f <- future({ sum(a) }), error = identity)
     + rm(list = "a")
     + stopifnot(inherits(res, "error"))
     +
     + ## Undo options changed in this test
     + options(ooptsT)
     +
     + message("*** cluster() - too large globals ... DONE")
     +
     + message("*** cluster() - installed libraries ...")
     + f <- try(cluster({
     + list(
     + libPaths = .libPaths()
     + )
     + }, workers = cl), silent = FALSE)
     + print(f)
     + stopifnot(inherits(f, "ClusterFuture"))
     + v <- value(f)
     + message(paste(capture.output(str(v)), collapse = "\n"))
     + message("*** cluster() - installed packages ... DONE")
     +
     +
     + message("*** cluster() - assert covr workaround ...")
     + f <- try(cluster({
     + future:::hpaste(1:100)
     + }, workers = cl), silent = FALSE)
     + print(f)
     + stopifnot(inherits(f, "ClusterFuture"))
     + v <- value(f)
     + message(v)
     + stopifnot(v == hpaste(1:100))
     + message("*** cluster() - assert covr workaround ... DONE")
     +
     + message(sprintf("Testing with %d cores on type = %s ... DONE",
     + cores, sQuote(type)))
     + } ## for (cores ...)
     +
     + message("*** cluster() - exceptions ...")
     +
     + res <- tryCatch(cluster(42L, workers = NA), error = identity)
     + print(res)
     + stopifnot(inherits(res, "error"))
     +
     + message("*** cluster() - exceptions ... DONE")
     +
     + message("*** cluster() - assert registry behavior ...")
     +
     + ## Explicitly created clusters are *not* added to the registry
     + cl <- parallel::makeCluster(1L, type = type, timeout = 60)
     + plan(cluster, workers = cl)
     + clR <- ClusterRegistry("get")
     + stopifnot(is.null(clR))
     +
     + ## ... and therefore changing plans shouldn't change anything
     + plan(sequential)
     + clR <- ClusterRegistry("get")
     + stopifnot(is.null(clR))
     +
     + message("*** cluster() - assert registry behavior ... DONE")
     +
     + ## Sanity checks
     + pid2 <- Sys.getpid()
     + message("Main PID (original): ", pid)
     + message("Main PID: ", pid2)
     + stopifnot(pid2 == pid)
     +
     + ## Cleanup
     + print(cl)
     + str(cl)
     + parallel::stopCluster(cl)
     + plan(sequential)
     +
     + cl1 <- parallel::makeCluster(1L, type = type, timeout = 60)
     + plan(cluster, workers = cl1)
     + f1 <- future(1)
     +
     + cl1 <- parallel::makeCluster(1L, type = type, timeout = 60)
     + plan(cluster, workers = cl1)
     +
     + message(sprintf("Test set #1 with cluster type %s ... DONE", sQuote(type)))
     + } ## for (type ...)
     Test set #1 with cluster type 'PSOCK' ...
     Testing with 1 cores on type = 'PSOCK' ...
     socket cluster with 1 nodes on host 'localhost'
     ClusterFuture:
     Label: '<none>'
     Expression:
     {
     42L
     }
     Lazy evaluation: FALSE
     Asynchronous evaluation: TRUE
     Local evaluation: TRUE
     Environment: <environment: R_GlobalEnv>
     Capture standard output: TRUE
     Capture condition classes: 'message', 'warning'
     Globals: <none>
     Packages: <none>
     L'Ecuyer-CMRG RNG seed: <none>
     Resolved: TRUE
     Value: <not collected>
     Conditions captured: <none>
     Early signalling: FALSE
     Owner process: 0849dc7e-4257-77ec-cddf-0125c0feb992
     Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
     [1] TRUE
     [1] 42
     ClusterFuture:
     Label: '<none>'
     Expression:
     {
     42L
     }
     Lazy evaluation: FALSE
     Asynchronous evaluation: TRUE
     Local evaluation: TRUE
     Environment: <environment: R_GlobalEnv>
     Capture standard output: TRUE
     Capture condition classes: 'message', 'warning'
     Globals: <none>
     Packages: <none>
     L'Ecuyer-CMRG RNG seed: <none>
     Resolved: TRUE
     Value: <not collected>
     Conditions captured: <none>
     Early signalling: FALSE
     Owner process: 0849dc7e-4257-77ec-cddf-0125c0feb992
     Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
     [1] TRUE
     [1] 42
     ClusterFuture:
     Label: '<none>'
     Expression:
     {
     b <- 3
     c <- 2
     a * b * c
     }
     Lazy evaluation: FALSE
     Asynchronous evaluation: TRUE
     Local evaluation: TRUE
     Environment: <environment: R_GlobalEnv>
     Capture standard output: TRUE
     Capture condition classes: 'message', 'warning'
     Globals: 1 objects totaling 56 bytes (numeric 'a' of 56 bytes)
     Packages: <none>
     L'Ecuyer-CMRG RNG seed: <none>
     Resolved: TRUE
     Value: <not collected>
     Conditions captured: <none>
     Early signalling: FALSE
     Owner process: 0849dc7e-4257-77ec-cddf-0125c0feb992
     Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
     [1] 0
     *** cluster() with globals and blocking
     - Creating cluster future #1 ...
     - Creating cluster future #2 ...
     - Creating cluster future #3 ...
     - Resolving 3 cluster futures
     *** cluster() and errors
     ClusterFuture:
     Label: '<none>'
     Expression:
     {
     stop("Whoops!")
     1
     }
     Lazy evaluation: FALSE
     Asynchronous evaluation: TRUE
     Local evaluation: TRUE
     Environment: <environment: R_GlobalEnv>
     Capture standard output: TRUE
     Capture condition classes: 'message', 'warning'
     Globals: <none>
     Packages: <none>
     L'Ecuyer-CMRG RNG seed: <none>
     Resolved: TRUE
     Value: <not collected>
     Conditions captured: <none>
     Early signalling: FALSE
     Owner process: 0849dc7e-4257-77ec-cddf-0125c0feb992
     Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
     <simpleError in eval(quote({ stop("Whoops!") 1}), new.env()): Whoops!>
     <simpleError in eval(quote({ stop("Whoops!") 1}), new.env()): Whoops!>
     <simpleError in eval(quote({ stop("Whoops!") 1}), new.env()): Whoops!>
     ClusterFuture:
     Label: '<none>'
     Expression:
     {
     stop(structure(list(message = "boom"), class = c("MyError",
     "error", "condition")))
     }
     Lazy evaluation: FALSE
     Asynchronous evaluation: TRUE
     Local evaluation: TRUE
     Environment: <environment: R_GlobalEnv>
     Capture standard output: TRUE
     Capture condition classes: 'message', 'warning'
     Globals: <none>
     Packages: <none>
     L'Ecuyer-CMRG RNG seed: <none>
     Resolved: TRUE
     Value: <not collected>
     Conditions captured: <none>
     Early signalling: FALSE
     Owner process: 0849dc7e-4257-77ec-cddf-0125c0feb992
     Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
     <MyError: boom>
     *** cluster() - too large globals ...
     Max total size of globals: 4104 bytes
     a: 4104 bytes
     ClusterFuture:
     Label: '<none>'
     Expression:
     {
     sum(a)
     }
     Lazy evaluation: FALSE
     Asynchronous evaluation: TRUE
     Local evaluation: TRUE
     Environment: <environment: R_GlobalEnv>
     Capture standard output: TRUE
     Capture condition classes: 'message', 'warning'
     Globals: 1 objects totaling 4.01 KiB (integer 'a' of 4.01 KiB)
     Packages: <none>
     L'Ecuyer-CMRG RNG seed: <none>
     Resolved: TRUE
     Value: <not collected>
     Conditions captured: <none>
     Early signalling: FALSE
     Owner process: 0849dc7e-4257-77ec-cddf-0125c0feb992
     Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
     [1] 514605
     a: 4112 bytes
     *** cluster() - too large globals ... DONE
     *** cluster() - installed libraries ...
     ClusterFuture:
     Label: '<none>'
     Expression:
     {
     list(libPaths = .libPaths())
     }
     Lazy evaluation: FALSE
     Asynchronous evaluation: TRUE
     Local evaluation: TRUE
     Environment: <environment: R_GlobalEnv>
     Capture standard output: TRUE
     Capture condition classes: 'message', 'warning'
     Globals: <none>
     Packages: <none>
     L'Ecuyer-CMRG RNG seed: <none>
     Resolved: TRUE
     Value: <not collected>
     Conditions captured: <none>
     Early signalling: FALSE
     Owner process: 0849dc7e-4257-77ec-cddf-0125c0feb992
     Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
     List of 1
     $ libPaths: chr [1:2] "/home/hornik/tmp/R.check/r-patched-gcc/Work/build/Packages" "/home/hornik/tmp/R.check/r-patched-gcc/Work/build/library"
     *** cluster() - installed packages ... DONE
     *** cluster() - assert covr workaround ...
     ClusterFuture:
     Label: '<none>'
     Expression:
     {
     future:::hpaste(1:100)
     }
     Lazy evaluation: FALSE
     Asynchronous evaluation: TRUE
     Local evaluation: TRUE
     Environment: <environment: R_GlobalEnv>
     Capture standard output: TRUE
     Capture condition classes: 'message', 'warning'
     Globals: <none>
     Packages: <none>
     L'Ecuyer-CMRG RNG seed: <none>
     Resolved: TRUE
     Value: <not collected>
     Conditions captured: <none>
     Early signalling: FALSE
     Owner process: 0849dc7e-4257-77ec-cddf-0125c0feb992
     Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
     1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100
     *** cluster() - assert covr workaround ... DONE
     Testing with 1 cores on type = 'PSOCK' ... DONE
     Testing with 2 cores on type = 'PSOCK' ...
     socket cluster with 2 nodes on host 'localhost'
     ClusterFuture:
     Label: '<none>'
     Expression:
     {
     42L
     }
     Lazy evaluation: FALSE
     Asynchronous evaluation: TRUE
     Local evaluation: TRUE
     Environment: <environment: R_GlobalEnv>
     Capture standard output: TRUE
     Capture condition classes: 'message', 'warning'
     Globals: <none>
     Packages: <none>
     L'Ecuyer-CMRG RNG seed: <none>
     Resolved: TRUE
     Value: <not collected>
     Conditions captured: <none>
     Early signalling: FALSE
     Owner process: 0849dc7e-4257-77ec-cddf-0125c0feb992
     Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
     [1] TRUE
     [1] 42
     Warning in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE, :
     port 11794 cannot be opened
     Error in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE, :
     Failed to launch and connect to R worker on local machine 'localhost' from local machine 'gimli'.
     * The error produced by socketConnection() was: 'cannot open the connection'
     * In addition, socketConnection() produced 1 warning(s):
     - Warning #1: 'port 11794 cannot be opened' (which suggests that this port is either already occupied by another process or blocked by the firewall on your local machine)
     * The localhost socket connection that failed to connect to the R worker used port 11794 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
     * Worker launch call: '/home/hornik/tmp/R.check/r-patched-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/cluster.R:gimli:hornik:24724' -e 'try(cat(Sys.getpid(),file="/tmp/RtmpCxH29D/future.parent=24724.60947d4ca853.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11794 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
     * Worker (PID 29785) was successfully killed: TRUE
     * Troubleshooting suggestions:
     - Suggestion #1: Set 'verbose=TRUE' to see more details.
     - Suggestion #2: Set 'outfile=NULL' to see output from worker.
     Calls: plan ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
     Execution halted
Flavor: r-patched-linux-x86_64

Version: 1.12.0
Check: examples
Result: ERROR
    Running examples in 'future-Ex.R' failed
Flavor: r-release-windows-ix86+x86_64