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 |
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