Running 'foreach_dofuture,cluster-missing-doFuture-pkg.R' [63s]
  Running 'foreach_dofuture,errors.R' [13s]
  Running 'foreach_dofuture,globals.R' [9s]
  Running 'foreach_dofuture,nested_colon.R' [18s]
  Running 'foreach_dofuture,nested_dofuture.R' [19s]
  Running 'foreach_dofuture,rng.R' [5s]
  Running 'foreach_dofuture.R' [4s]
  Running 'foreach_dopar,cluster-missing-doFuture-pkg.R' [63s]
  Running 'foreach_dopar,doRNG,dopar.R' [3s]
  Running 'foreach_dopar,doRNG,dorng.R' [7s]
  Running 'foreach_dopar,errors.R' [9s]
  Running 'foreach_dopar,globals.R' [9s]
  Running 'foreach_dopar,nested_colon.R' [16s]
  Running 'foreach_dopar,nested_dopar.R' [21s]
  Running 'foreach_dopar,options-for-export.R' [6s]
  Running 'foreach_dopar.R' [4s]
  Running 'makeChunks.R' [4s]
  Running 'options,nested.R' [4s]
  Running 'registerDoFuture.R' [2s]
  Running 'times.R' [2s]
  Running 'utils.R' [1s]
  Running 'withDoRNG.R' [5s]
Running the tests in 'tests/foreach_dofuture,cluster-missing-doFuture-pkg.R' failed.
Complete output:
  > source("incl/start.R")
  Loading required package: foreach
  Loading required package: future
  R version 4.4.3 (2025-02-28 ucrt)
  Platform: x86_64-w64-mingw32/x64
  Running under: Windows Server 2022 x64 (build 20348)
  
  Matrix products: default
  
  
  locale:
  [1] LC_COLLATE=C                 LC_CTYPE=German_Germany.utf8
  [3] LC_MONETARY=C                LC_NUMERIC=C                
  [5] LC_TIME=C                   
  
  time zone: Europe/Berlin
  tzcode source: internal
  
  attached base packages:
  [1] stats     graphics  grDevices utils     datasets  methods   base     
  
  other attached packages:
  [1] doFuture_1.0.2 future_1.40.0  foreach_1.5.2 
  
  loaded via a namespace (and not attached):
   [1] compiler_4.4.3      parallelly_1.43.0   tools_4.4.3        
   [4] parallel_4.4.3      future.apply_1.11.3 listenv_0.9.1      
   [7] codetools_0.2-20    iterators_1.0.14    digest_0.6.37      
  [10] globals_0.17.0     
  > options(future.debug = FALSE)
  > 
  > message("*** cluster() ...")
  *** cluster() ...
  > 
  > message("Library paths: ", paste(sQuote(.libPaths()), collapse = ", "))
  Library paths: 'D:/temp/2025_04_21_01_50_00_22712/Rtmpk1kbEm/RLIBS_24ca078352101', 'D:/RCompile/recent/R-4.4.3/library'
  > message("Package path: ", sQuote(system.file(package = "future")))
  Package path: 'D:/RCompile/CRANpkg/lib/4.4/future'
  > 
  > types <- "PSOCK"
  > #if (supportsMulticore()) types <- c(types, "FORK")
  > 
  > setupClusterWithoutPkgs <- function(type = "PSOCK",
  +                                     withs = c("digest", "globals",
  +                                               "listenv", "future"),
  +                                     withouts = c("doFuture")) {
  +   cl <- parallel::makeCluster(1L, type = type, timeout = 60)
  + 
  +   ## Emulate a worker that does not have 'future' installed.
  +   ## by setting a different user library path on the worker.
  +   libs <- parallel::clusterEvalQ(cl, .libPaths(tempdir()))[[1]]
  +   attr(cl, "libs") <- libs
  + 
  +   ## 'withouts' tops 'withs' for conveniency
  +   withs <- setdiff(withs, withouts)
  +   
  +   ## "Install" any 'withs' packages?
  +   if (length(withs) > 0L) {
  +     paths <- find.package(withs)
  +     res <- parallel::clusterCall(cl, fun = sapply, X = paths,
  +                                  FUN = file.copy, to = libs[1],
  +                                  recursive = TRUE)[[1]]
  +     res <- parallel::clusterCall(cl, fun = sapply, X = withs,
  +                                  FUN = requireNamespace)[[1]]
  +   }
  +   attr(cl, "withs") <- res
  + 
  +   ## Check whether 'future' is still available on the worker or not.
  +   ## It could be that it is installed in the system library path, which
  +   ## in case we cannot "hide" the future package from the worker.
  +   res <- parallel::clusterCall(cl, fun = sapply, X = withouts,
  +                                    FUN = requireNamespace)[[1]]
  +   attr(cl, "withouts") <- res
  + 
  +   cl
  + }
  > 
  > cl <- NULL
  > for (type in types) {
  +   message(sprintf("Test set #1 with cluster type %s ...", sQuote(type)))
  + 
  +   cl <- setupClusterWithoutPkgs(type, withouts = c("future", "doFuture"))  
  +   if (all(attr(cl, "withs")) && !all(attr(cl, "withouts"))) {
  +     plan(cluster, workers = cl, .init = FALSE)
  +     
  +     ## Here we will get:
  +     ##   <UnexpectedFutureResultError: Unexpected result (of class
  +     ##   'snow-try-error' != 'FutureResult') retrieved for ClusterFuture
  +     ##   future (label = '<none>', expression = '{ ... }'):
  +     ##   Package 'future' is not installed on worker (r_version: ...)>
  +     ## Note: This error is produced by the future backend when it recieves
  +     ##       the unexpected results.
  +     res <- tryCatch({
  +       y <- foreach(ii = 1:3) %dofuture% ii
  +     }, error = identity)
  +     print(res)
  +     stopifnot(inherits(res, "FutureError"))
  +   }
  +   parallel::stopCluster(cl)
  +   cl <- NULL
  +   
  +   cl <- setupClusterWithoutPkgs(type)  
  +   if (all(attr(cl, "withs")) && !all(attr(cl, "withouts"))) {
  +     plan(cluster, workers = cl, .init = FALSE)
  +     
  +     ## Here we will get:
  +     ##   <UnexpectedFutureResultError: Unexpected result (of class
  +     ##   'snow-try-error' != 'FutureResult') retrieved for ClusterFuture
  +     ##   future (label = '<none>', expression = '{ ... }'):
  +     ##   there is no package called 'doFuture'>
  +     ## Note: This error is produced by the future backend when it recieves
  +     ##       the unexpected results.
  +     res <- tryCatch({
  +       y <- foreach(ii = 1:3) %dofuture% ii
  +     }, error = identity)
  +     print(res)
  +     stopifnot(inherits(res, "FutureError"))
  +   }
  +   parallel::stopCluster(cl)
  +   cl <- NULL
  +   
  +   plan(sequential)
  +   
  +   message(sprintf("Test set #1 with cluster type %s ... DONE", sQuote(type)))
  + } ## for (type ...)
  Test set #1 with cluster type 'PSOCK' ...
  [19:15:42.131] doFuture2() ...
  [19:15:42.213] Number of chunks: 1
  [19:15:42.214] Number of futures (= number of chunks): 1
  [19:15:42.214] seed = FALSE
  [19:15:42.214]  NULL
  [19:15:42.217] seed = FALSE
  [19:15:42.218] seed = FALSE
  [19:15:42.218] - %dofuture% R expression:
  [19:15:42.218] ii
  [19:15:42.219] - foreach iterator arguments: [1] 'ii'
  [19:15:42.219] - dummy globals (as locals): [1] 'ii'
  [19:15:42.220] - R expression (map-reduce expression adjusted for RNG):
  [19:15:42.220] {
  [19:15:42.220]     NULL
  [19:15:42.220]     "# doFuture():::doFuture2(): process chunk of elements"
  [19:15:42.220]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [19:15:42.220]         ...future.x_jj <- ...future.x_ii[[jj]]
  [19:15:42.220]         {
  [19:15:42.220]             NULL
  [19:15:42.220]             ii <- NULL
  [19:15:42.220]         }
  [19:15:42.220]         ...future.env <- environment()
  [19:15:42.220]         local({
  [19:15:42.220]             for (name in names(...future.x_jj)) {
  [19:15:42.220]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [19:15:42.220]                   inherits = FALSE)
  [19:15:42.220]             }
  [19:15:42.220]         })
  [19:15:42.220]         NULL
  [19:15:42.220]         tryCatch(ii, error = identity)
  [19:15:42.220]     })
  [19:15:42.220] }
  [19:15:42.221] - identifying globals and packages ...
  [19:15:42.221]   - Argument 'globals':
  
  [19:15:42.222]  logi TRUE
  [19:15:42.222]  - attr(*, "add")= chr "...future.x_ii"
  [19:15:42.222]  - attr(*, "ignore")= chr "ii"
  [19:15:42.226]   - R expression (map-reduce expression searched for globals):
  [19:15:42.227] {
  [19:15:42.227]     NULL
  [19:15:42.227]     "# doFuture():::doFuture2(): process chunk of elements"
  [19:15:42.227]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [19:15:42.227]         ...future.x_jj <- ...future.x_ii[[jj]]
  [19:15:42.227]         {
  [19:15:42.227]             NULL
  [19:15:42.227]             ii <- NULL
  [19:15:42.227]         }
  [19:15:42.227]         ...future.env <- environment()
  [19:15:42.227]         local({
  [19:15:42.227]             for (name in names(...future.x_jj)) {
  [19:15:42.227]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [19:15:42.227]                   inherits = FALSE)
  [19:15:42.227]             }
  [19:15:42.227]         })
  [19:15:42.227]         NULL
  [19:15:42.227]         tryCatch(ii, error = identity)
  [19:15:42.227]     })
  [19:15:42.227] }
  [19:15:42.250]   - R expression (%dofuture% expression searched for globals):
  [19:15:42.250] ii
  [19:15:42.253] - Globals in %dofuture% R expression not in map-reduce expression:
  [19:15:42.254]   - Appending 0 globals only found in the vanilla %dofuture% expression: 
  [19:15:42.254]   - globals: [1] '...future.x_ii'
  [19:15:42.254] List of 1
  [19:15:42.254]  $ ...future.x_ii: num 42
  [19:15:42.254]  - attr(*, "where")=List of 1
  [19:15:42.254]   ..$ ...future.x_ii:<environment: R_EmptyEnv> 
  [19:15:42.254]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [19:15:42.254]  - attr(*, "resolved")= logi FALSE
  [19:15:42.254]  - attr(*, "total_size")= num 39
  [19:15:42.261]   - packages: [1] 'doFuture'
  [19:15:42.261] - identifying globals and packages ... DONE
  [19:15:42.261] Launching 1 futures (chunks) ...
  [19:15:42.262] Chunk #1 of 1 ...
  [19:15:42.262]  - Finding globals in 'args_list' for chunk #1 ...
  [19:15:42.264] 
  [19:15:42.264] 
  [19:15:42.265]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [19:15:42.265]  - seeds: <none>
  [19:15:42.275] Chunk #1 of 1 ... DONE
  [19:15:42.275] Launching 1 futures (chunks) ... DONE
  [19:15:42.276] - resolving futures
  [19:15:42.276]   - gathering results & relaying conditions (except errors)
  <FutureInterruptError: A future ('doFuture2-1') of class ClusterFuture was interrupted, while running on 'localhost'>
  
  
  Future UUID: 3ae73bb53c5e85ca275d3174c69095d8-2
  
  
  DEBUG: BEGIN TROUBLESHOOTING HELP
  Future involved:
  ClusterFuture:
  Label: 'doFuture2-1'
  Expression:
  {
      NULL
      "# doFuture():::doFuture2(): process chunk of elements"
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              NULL
              ii <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          NULL
          tryCatch(ii, error = identity)
      })
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: R_GlobalEnv
  Capture standard output: TRUE
  Capture condition classes: 'condition' (excluding '<none>')
  Immediate condition classes: 'immediateCondition'
  Globals: 1 objects totaling 194 bytes (list '...future.x_ii' of 194 bytes)
  Packages: 1 packages ('doFuture')
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 3ae73bb53c5e85ca275d3174c69095d8
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future'
  
  DEBUG: END TROUBLESHOOTING HELP
  Error in serialize(data, node$con) : error writing to connection
  Calls: <Anonymous> ... postNode -> sendData -> sendData.SOCKnode -> serialize
  Execution halted
Running the tests in 'tests/foreach_dopar,cluster-missing-doFuture-pkg.R' failed.
Complete output:
  > source("incl/start.R")
  Loading required package: foreach
  Loading required package: future
  R version 4.4.3 (2025-02-28 ucrt)
  Platform: x86_64-w64-mingw32/x64
  Running under: Windows Server 2022 x64 (build 20348)
  
  Matrix products: default
  
  
  locale:
  [1] LC_COLLATE=C                 LC_CTYPE=German_Germany.utf8
  [3] LC_MONETARY=C                LC_NUMERIC=C                
  [5] LC_TIME=C                   
  
  time zone: Europe/Berlin
  tzcode source: internal
  
  attached base packages:
  [1] stats     graphics  grDevices utils     datasets  methods   base     
  
  other attached packages:
  [1] doFuture_1.0.2 future_1.40.0  foreach_1.5.2 
  
  loaded via a namespace (and not attached):
   [1] compiler_4.4.3      parallelly_1.43.0   tools_4.4.3        
   [4] parallel_4.4.3      future.apply_1.11.3 listenv_0.9.1      
   [7] codetools_0.2-20    iterators_1.0.14    digest_0.6.37      
  [10] globals_0.17.0     
  > options(future.debug = FALSE)
  > 
  > message("*** cluster() ...")
  *** cluster() ...
  > 
  > registerDoFuture()
  > 
  > message("Library paths: ", paste(sQuote(.libPaths()), collapse = ", "))
  Library paths: 'D:/temp/2025_04_21_01_50_00_22712/Rtmpk1kbEm/RLIBS_24ca078352101', 'D:/RCompile/recent/R-4.4.3/library'
  > message("Package path: ", sQuote(system.file(package = "future")))
  Package path: 'D:/RCompile/CRANpkg/lib/4.4/future'
  > 
  > types <- "PSOCK"
  > #if (supportsMulticore()) types <- c(types, "FORK")
  > 
  > setupClusterWithoutPkgs <- function(type = "PSOCK",
  +                                     withs = c("digest", "globals",
  +                                               "listenv", "future"),
  +                                     withouts = c("doFuture")) {
  +   cl <- parallel::makeCluster(1L, type = type, timeout = 60)
  + 
  +   ## Emulate a worker that does not have 'future' installed.
  +   ## by setting a different user library path on the worker.
  +   libs <- parallel::clusterEvalQ(cl, .libPaths(tempdir()))[[1]]
  +   attr(cl, "libs") <- libs
  + 
  +   ## 'withouts' tops 'withs' for conveniency
  +   withs <- setdiff(withs, withouts)
  +   
  +   ## "Install" any 'withs' packages?
  +   if (length(withs) > 0L) {
  +     paths <- find.package(withs)
  +     res <- parallel::clusterCall(cl, fun = sapply, X = paths,
  +                                  FUN = file.copy, to = libs[1],
  +                                  recursive = TRUE)[[1]]
  +     res <- parallel::clusterCall(cl, fun = sapply, X = withs,
  +                                  FUN = requireNamespace)[[1]]
  +   }
  +   attr(cl, "withs") <- res
  + 
  +   ## Check whether 'future' is still available on the worker or not.
  +   ## It could be that it is installed in the system library path, which
  +   ## in case we cannot "hide" the future package from the worker.
  +   res <- parallel::clusterCall(cl, fun = sapply, X = withouts,
  +                                    FUN = requireNamespace)[[1]]
  +   attr(cl, "withouts") <- res
  + 
  +   cl
  + }
  > 
  > 
  > cl <- NULL
  > for (type in types) {
  +   message(sprintf("Test set #1 with cluster type %s ...", sQuote(type)))
  + 
  +   cl <- setupClusterWithoutPkgs(type, withouts = c("future", "doFuture"))  
  +   if (all(attr(cl, "withs")) && !all(attr(cl, "withouts"))) {
  +     plan(cluster, workers = cl, .init = FALSE)
  +     
  +     ## Here we will get:
  +     ##   <UnexpectedFutureResultError: Unexpected result (of class
  +     ##   'snow-try-error' != 'FutureResult') retrieved for ClusterFuture
  +     ##   future (label = '<none>', expression = '{ ... }'):
  +     ##   Package 'future' is not installed on worker (r_version: ...)>
  +     ## Note: This error is produced by the future backend when it recieves
  +     ##       the unexpected results.
  +     res <- tryCatch({
  +       y <- foreach(ii = 1:3) %dopar% ii
  +     }, error = identity)
  +     print(res)
  +     stopifnot(inherits(res, "FutureError"))
  +   }
  +   parallel::stopCluster(cl)
  +   cl <- NULL
  +   
  +   cl <- setupClusterWithoutPkgs(type)  
  +   if (all(attr(cl, "withs")) && !all(attr(cl, "withouts"))) {
  +     plan(cluster, workers = cl, .init = FALSE)
  +     
  +     ## Here we will get:
  +     ##   <UnexpectedFutureResultError: Unexpected result (of class
  +     ##   'snow-try-error' != 'FutureResult') retrieved for ClusterFuture
  +     ##   future (label = '<none>', expression = '{ ... }'):
  +     ##   there is no package called 'doFuture'>
  +     ## Note: This error is produced by the future backend when it recieves
  +     ##       the unexpected results.
  +     res <- tryCatch({
  +       y <- foreach(ii = 1:3) %dopar% ii
  +     }, error = identity)
  +     print(res)
  +     stopifnot(inherits(res, "FutureError"))
  +   }
  +   parallel::stopCluster(cl)
  +   cl <- NULL
  +   
  +   plan(sequential)
  +   
  +   message(sprintf("Test set #1 with cluster type %s ... DONE", sQuote(type)))
  + } ## for (type ...)
  Test set #1 with cluster type 'PSOCK' ...
  [19:17:54.214] doFuture() ...
  [19:17:54.216] - dummy globals (as locals): [1] 'ii'
  [19:17:54.217] - R expression:
  [19:17:54.217] {
  [19:17:54.217]     "# doFuture():::doFuture(): Make sure that foreach uses 'doFuture'"
  [19:17:54.217]     "# also in nested calls                                           "
  [19:17:54.217]     doFuture::registerDoFuture()
  [19:17:54.217]     "# doFuture():::doFuture(): process chunk of elements"
  [19:17:54.217]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [19:17:54.217]         ...future.x_jj <- ...future.x_ii[[jj]]
  [19:17:54.217]         {
  [19:17:54.217]             NULL
  [19:17:54.217]             ii <- NULL
  [19:17:54.217]         }
  [19:17:54.217]         ...future.env <- environment()
  [19:17:54.217]         local({
  [19:17:54.217]             for (name in names(...future.x_jj)) {
  [19:17:54.217]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [19:17:54.217]                   inherits = FALSE)
  [19:17:54.217]             }
  [19:17:54.217]         })
  [19:17:54.217]         tryCatch(ii, error = identity)
  [19:17:54.217]     })
  [19:17:54.217] }
  [19:17:54.218] - identifying globals and packages ...
  [19:17:54.241] List of 1
  [19:17:54.241]  $ ...future.x_ii: NULL
  [19:17:54.241]  - attr(*, "where")=List of 1
  [19:17:54.241]   ..$ ...future.x_ii:<environment: R_EmptyEnv> 
  [19:17:54.241]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [19:17:54.241]  - attr(*, "resolved")= logi FALSE
  [19:17:54.241]  - attr(*, "total_size")= num 27
  [19:17:54.253]   - R expression:
  [19:17:54.254] {
  [19:17:54.254]     "# doFuture():::doFuture(): Make sure that foreach uses 'doFuture'"
  [19:17:54.254]     "# also in nested calls                                           "
  [19:17:54.254]     doFuture::registerDoFuture()
  [19:17:54.254]     "# doFuture():::doFuture(): process chunk of elements"
  [19:17:54.254]     lapply(seq_along(...future.x_ii), FUN = function(jj) {
  [19:17:54.254]         ...future.x_jj <- ...future.x_ii[[jj]]
  [19:17:54.254]         {
  [19:17:54.254]             NULL
  [19:17:54.254]             ii <- NULL
  [19:17:54.254]         }
  [19:17:54.254]         ...future.env <- environment()
  [19:17:54.254]         local({
  [19:17:54.254]             for (name in names(...future.x_jj)) {
  [19:17:54.254]                 assign(name, ...future.x_jj[[name]], envir = ...future.env, 
  [19:17:54.254]                   inherits = FALSE)
  [19:17:54.254]             }
  [19:17:54.254]         })
  [19:17:54.254]         tryCatch(ii, error = identity)
  [19:17:54.254]     })
  [19:17:54.254] }
  [19:17:54.255]   - globals: [1] '...future.x_ii'
  [19:17:54.256] List of 1
  [19:17:54.256]  $ ...future.x_ii: NULL
  [19:17:54.256]  - attr(*, "where")=List of 1
  [19:17:54.256]   ..$ ...future.x_ii:<environment: R_EmptyEnv> 
  [19:17:54.256]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
  [19:17:54.256]  - attr(*, "resolved")= logi FALSE
  [19:17:54.256]  - attr(*, "total_size")= num 27
  [19:17:54.263]   - packages: [1] 'doFuture'
  [19:17:54.263] - identifying globals and packages ... DONE
  [19:17:54.319] Number of chunks: 1
  [19:17:54.320] Number of futures (= number of chunks): 1
  [19:17:54.320] Launching 1 futures (chunks) ...
  [19:17:54.320] Chunk #1 of 1 ...
  [19:17:54.321]  - Finding globals in 'args_list' chunk #1 ...
  [19:17:54.322] 
  [19:17:54.322] 
  [19:17:54.322]  - Finding globals in 'args_list' for chunk #1 ... DONE
  [19:17:54.331] Chunk #1 of 1 ... DONE
  [19:17:54.331] Launching 1 futures (chunks) ... DONE
  [19:17:54.331] - resolving futures
  [19:17:54.332]   - gathering results & relaying conditions (except errors)
  <FutureInterruptError: A future ('doFuture-1') of class ClusterFuture was interrupted, while running on 'localhost'>
  
  
  Future UUID: c15bfa5a41f38e0182f75b847f5c7cba-2
  
  
  DEBUG: BEGIN TROUBLESHOOTING HELP
  Future involved:
  ClusterFuture:
  Label: 'doFuture-1'
  Expression:
  {
      "# doFuture():::doFuture(): Make sure that foreach uses 'doFuture'"
      "# also in nested calls                                           "
      doFuture::registerDoFuture()
      "# doFuture():::doFuture(): process chunk of elements"
      lapply(seq_along(...future.x_ii), FUN = function(jj) {
          ...future.x_jj <- ...future.x_ii[[jj]]
          {
              NULL
              ii <- NULL
          }
          ...future.env <- environment()
          local({
              for (name in names(...future.x_jj)) {
                  assign(name, ...future.x_jj[[name]], envir = ...future.env, 
                    inherits = FALSE)
              }
          })
          tryCatch(ii, error = identity)
      })
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: R_GlobalEnv
  Capture standard output: TRUE
  Capture condition classes: 'condition' (excluding '<none>')
  Immediate condition classes: 'immediateCondition'
  Globals: 1 objects totaling 194 bytes (list '...future.x_ii' of 194 bytes)
  Packages: 1 packages ('doFuture')
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: c15bfa5a41f38e0182f75b847f5c7cba
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future'
  
  DEBUG: END TROUBLESHOOTING HELP
  Error in serialize(data, node$con) : error writing to connection
  Calls: <Anonymous> ... postNode -> sendData -> sendData.SOCKnode -> serialize
  Execution halted