getExpression(): Remove arguments 'stdout', 'split', and 'local'

getExpression() for ClusterFuture: Remove argument 'conditionClasses' and 'resignalImmediateConditions'
getExpression() for MulticoreFuture: Remove argument 'conditionClasses' and 'resignalImmediateConditions'

Author: HenrikBengtsson

DESCRIPTION

@@ -1,5 +1,5 @@
 Package: future
-Version: 1.34.0-9100
+Version: 1.34.0-9101
 Title: Unified Parallel and Distributed Processing in R for Everyone
 Imports:
     digest,

R/ClusterFuture-class.R

@@ -656,37 +656,32 @@ getExpression.ClusterFuture <- local({
   })
 
 
-  function(future, expr = future$expr, immediateConditions = TRUE, conditionClasses = future$conditions, resignalImmediateConditions = getOption("future.psock.relay.immediate", immediateConditions), ...) {
+  function(future, expr = future$expr, immediateConditions = TRUE, ...) {
     ## Assert that no arguments but the first is passed by position
     assert_no_positional_args_but_first()
 
     ## Inject code for resignaling immediateCondition:s?
-    if (resignalImmediateConditions && immediateConditions) {
-      ## Preserve condition classes to be ignored
-      exclude <- attr(conditionClasses, "exclude", exact = TRUE)
-    
-      immediateConditionClasses <- getOption("future.relay.immediate", "immediateCondition")
-      conditionClasses <- unique(c(conditionClasses, immediateConditionClasses))
-  
-      if (length(conditionClasses) > 0L) {
-        ## Does the cluster node communicate with a connection?
-        ## (if not, it's via MPI)
-        workers <- future$workers
-        ## AD HOC/FIXME: Here 'future$node' is yet not assigned, so we look at
-        ## the first worker and assume the others are the same. /HB 2019-10-23
-        cl <- workers[1L]
-        node <- cl[[1L]]
-        con <- node$con
-        if (!is.null(con)) {
-          expr <- bquote_apply(tmpl_expr_conditions)
-        } ## if (!is.null(con))
-      } ## if (length(conditionClasses) > 0)
-      
-      ## Set condition classes to be ignored in case changed
-      attr(conditionClasses, "exclude") <- exclude
+    if (immediateConditions) {
+      resignalImmediateConditions <- getOption("future.psock.relay.immediate", TRUE)
+      if (resignalImmediateConditions) {
+        immediateConditionClasses <- getOption("future.relay.immediate", "immediateCondition")
+        if (length(immediateConditionClasses) > 0L) {
+          ## Does the cluster node communicate with a connection?
+          ## (if not, it's via MPI)
+          workers <- future$workers
+          ## AD HOC/FIXME: Here 'future$node' is yet not assigned, so we look at
+          ## the first worker and assume the others are the same. /HB 2019-10-23
+          cl <- workers[1L]
+          node <- cl[[1L]]
+          con <- node$con
+          if (!is.null(con)) {
+            expr <- bquote_apply(tmpl_expr_conditions)
+          } ## if (!is.null(con))
+        }
+      }
     } ## if (resignalImmediateConditions && immediateConditions)
 
-    NextMethod(expr = expr, immediateConditions = immediateConditions, conditionClasses = conditionClasses)
+    NextMethod(expr = expr, immediateConditions = immediateConditions)
   }
 })
 

R/Future-class.R

@@ -662,10 +662,14 @@ getExpression.Future <- local({
     future:::evalFuture(core = .(core), local = .(local), stdout = .(stdout), conditionClasses = .(conditionClasses), split = .(split), immediateConditions = .(immediateConditions), immediateConditionClasses = .(immediateConditionClasses), strategiesR = .(strategiesR), forwardOptions = .(forwardOptions), threads = .(threads), cleanup = .(cleanup))
   })
 
-  function(future, expr = future$expr, seed = future$seed, local = future$local, stdout = future$stdout, conditionClasses = future$conditions, split = future$split, immediateConditions = FALSE, mc.cores = NULL, threads = NA_integer_, cleanup = TRUE, ...) {
+  function(future, expr = future$expr, conditionClasses = future$conditions, immediateConditions = FALSE, mc.cores = NULL, threads = NA_integer_, cleanup = TRUE, ...) {
     debug <- getOption("future.debug", FALSE)
     ##  mdebug("getExpression() ...")
 
+    local <- future$local
+    stdout <- future$stdout
+    split <- future$split
+
     if (is.null(split)) split <- FALSE
     stop_if_not(is.logical(split), length(split) == 1L, !is.na(split))
 
@@ -714,15 +718,14 @@ getExpression.Future <- local({
       expr     = expr,
       globals  = globals,
       packages = pkgs,
-      seed     = seed
+      seed     = future$seed
     )
 
-    conditionClassesExclude <- attr(conditionClasses, "exclude", exact = TRUE)
-    muffleInclude <- attr(conditionClasses, "muffleInclude", exact = TRUE)
-    if (is.null(muffleInclude)) muffleInclude <- "^muffle"
-    
     if (immediateConditions && !is.null(conditionClasses)) {
       immediateConditionClasses <- getOption("future.relay.immediate", "immediateCondition")
+      conditionClassesExclude <- attr(conditionClasses, "exclude", exact = TRUE)
+      muffleInclude <- attr(conditionClasses, "muffleInclude", exact = TRUE)
+      if (is.null(muffleInclude)) muffleInclude <- "^muffle"
       conditionClasses <- unique(c(conditionClasses, immediateConditionClasses))
       attr(conditionClasses, "exclude") <- conditionClassesExclude
       attr(conditionClasses, "muffleInclude") <- muffleInclude

R/MulticoreFuture-class.R

@@ -299,7 +299,7 @@ result.MulticoreFuture <- function(future, ...) {
 
 #' @export
 getExpression.MulticoreFuture <- local({
-  function(future, expr = future$expr, mc.cores = 1L, immediateConditions = TRUE, conditionClasses = future$conditions, resignalImmediateConditions = getOption("future.multicore.relay.immediate", immediateConditions), ...) {
+  function(future, expr = future$expr, mc.cores = 1L, immediateConditions = TRUE, ...) {
     ## Assert that no arguments but the first is passed by position
     assert_no_positional_args_but_first()
 
@@ -318,22 +318,17 @@ getExpression.MulticoreFuture <- local({
     }
 
     ## Inject code for resignaling immediateCondition:s?
-    if (resignalImmediateConditions && immediateConditions) {
-      ## Preserve condition classes to be ignored
-      exclude <- attr(conditionClasses, "exclude", exact = TRUE)
-    
-      immediateConditionClasses <- getOption("future.relay.immediate", "immediateCondition")
-      conditionClasses <- unique(c(conditionClasses, immediateConditionClasses))
-  
-      if (length(conditionClasses) > 0L) {
-        ## Communicate via the file system
-        expr <- bquote_apply(tmpl_expr_send_immediateConditions_via_file)
-      } ## if (length(conditionClasses) > 0)
-      
-      ## Set condition classes to be ignored in case changed
-      attr(conditionClasses, "exclude") <- exclude
+    if (immediateConditions) {
+      resignalImmediateConditions <- getOption("future.multicore.relay.immediate", TRUE)
+      if (resignalImmediateConditions) {
+        immediateConditionClasses <- getOption("future.relay.immediate", "immediateCondition")
+        if (length(immediateConditionClasses) > 0L) {
+          ## Communicate via the file system
+          expr <- bquote_apply(tmpl_expr_send_immediateConditions_via_file)
+        }
+      }
     } ## if (resignalImmediateConditions && immediateConditions)
 
-    NextMethod(expr = expr, mc.cores = mc.cores, immediateConditions = immediateConditions, conditionClasses = conditionClasses, threads = threads)
+    NextMethod(expr = expr, mc.cores = mc.cores, immediateConditions = immediateConditions, threads = threads)
   }
 })

R/expressions.R

@@ -22,6 +22,10 @@ evalFuture <- function(core, local = FALSE, stdout = TRUE, conditionClasses = ch
     length(cleanup) == 1L && is.logical(cleanup) && !is.na(cleanup)
   )
 
+  if (!immediateConditions) {
+    immediateConditionClasses <- character(0L)
+  }
+
   ## Is it possible to force single-threaded processing?
   if (!is.na(threads)) {
     ## Setting other than single-threaded processing is currently not
@@ -453,13 +457,13 @@ evalFuture <- function(core, local = FALSE, stdout = TRUE, conditionClasses = ch
           ## Relay 'immediateCondition' conditions immediately?
           ## If so, then do not muffle it and flag it as signalled
           ## already here.
-          signal <- immediateConditions && inherits(cond, immediateConditionClasses)
+          signal <- inherits(cond, immediateConditionClasses)
           ## Record condition
           ...future.conditions[[length(...future.conditions) + 1L]] <<- list(
             condition = cond,
             signaled = as.integer(signal)
           )
-          if (immediateConditions && !split && !signal) {
+          if (length(immediateConditionClasses) > 0 && !split && !signal) {
             muffleCondition(cond, pattern = muffleInclude)
           }
         } else {