add isProcessForkedChild() for tbb fork-safety checks (#244)

* add isForkedChild() for tbb fork-safety checks

closes #243.

tbb does not support being used after fork(). downstream packages can't
reliably detect this themselves because rcppparallel — and therefore tbb —
may have been loaded into the parent long before the downstream package
gets a chance to record a baseline pid.

capture getpid() in R_init_RcppParallel and expose RcppParallel::isForkedChild()
(c++) plus isForkedChild() (r) so callers can fall back to a serial path
when running inside a fork()'d child (e.g. under parallel::mclapply).
windows is a no-op (always false) since it has no fork().

* rename isForkedChild() to isProcessForkedChild()

avoids a name collision with parallelly::isForkedChild(), which has
slightly different semantics (it detects any forked child, whereas we
detect a fork() occurring after RcppParallel was loaded).

Author: kevinushey

DESCRIPTION

@@ -35,5 +35,5 @@ License: GPL (>= 3)
 URL: https://rcppcore.github.io/RcppParallel/, https://github.com/RcppCore/RcppParallel
 BugReports: https://github.com/RcppCore/RcppParallel/issues
 Biarch: TRUE
-RoxygenNote: 7.3.2
+RoxygenNote: 7.3.3
 Encoding: UTF-8

NAMESPACE

@@ -5,5 +5,6 @@ export(LdFlags)
 export(RcppParallel.package.skeleton)
 export(RcppParallelLibs)
 export(defaultNumThreads)
+export(isProcessForkedChild)
 export(setThreadOptions)
 export(tbbLibraryPath)

NEWS.md

@@ -12,6 +12,14 @@
 
 # RcppParallel 6.0.0
 
+* RcppParallel now provides `isProcessForkedChild()` (R) and
+  `RcppParallel::isProcessForkedChild()` (C++), which return `TRUE` when the
+  current process is a `fork()` of the process in which RcppParallel was
+  loaded.
+  Packages dispatching parallel work from within `parallel::mclapply()` (or
+  similar) should consult this and fall back to a serial path, as TBB does
+  not support use after fork. (#243)
+
 * RcppParallel no longer includes tbb headers as part of the RcppParallel/TBB.h
   header, and instead only exposes its TBB-specific APIs for parallel work.
 

R/fork.R

@@ -0,0 +1,26 @@
+#' Is the Current Process a Forked Child?
+#'
+#' Returns `TRUE` if the current process is a `fork()` of the process in which
+#' RcppParallel was originally loaded.
+#'
+#' Intel TBB — the parallel backend used by `parallelFor()` and
+#' `parallelReduce()` — does not support being used in a child process after
+#' `fork()`. Packages that may be invoked from within `parallel::mclapply()`
+#' or similar fork-based parallelism should call `isProcessForkedChild()` and
+#' fall back to a serial code path when it returns `TRUE`.
+#'
+#' On Windows, which has no `fork()`, this always returns `FALSE`.
+#'
+#' @return A length-one logical.
+#'
+#' @examples
+#' \dontrun{
+#' library(RcppParallel)
+#' isProcessForkedChild()
+#' parallel::mclapply(1:2, function(i) RcppParallel::isProcessForkedChild())
+#' }
+#'
+#' @export
+isProcessForkedChild <- function() {
+   .Call("isProcessForkedChild", PACKAGE = "RcppParallel")
+}

inst/include/RcppParallel.h

@@ -22,6 +22,7 @@
 #endif
 
 #include "RcppParallel/Backend.h"
+#include "RcppParallel/Fork.h"
 #include "RcppParallel/RVector.h"
 #include "RcppParallel/RMatrix.h"
 

inst/include/RcppParallel/Fork.h

@@ -0,0 +1,17 @@
+#ifndef __RCPP_PARALLEL_FORK__
+#define __RCPP_PARALLEL_FORK__
+
+namespace RcppParallel {
+
+// Returns true if the current process is a fork() of the process in which
+// RcppParallel was originally loaded. Always returns false on Windows, which
+// has no fork().
+//
+// Intel TBB does not support being used after fork(). Code paths reachable
+// from fork()'d children (for example, via parallel::mclapply) should call
+// this and fall back to a serial implementation when it returns true.
+bool isProcessForkedChild();
+
+} // namespace RcppParallel
+
+#endif // __RCPP_PARALLEL_FORK__

man/isProcessForkedChild.Rd

@@ -1,19 +1,52 @@
-
 #include <R.h>
 #include <Rinternals.h>
 #include <stdlib.h> // for NULL
 #include <R_ext/Rdynload.h>
 
+#ifndef _WIN32
+# include <sys/types.h>
+# include <unistd.h>
+#endif
+
+namespace RcppParallel {
+
+#ifndef _WIN32
+static pid_t s_loadPid = 0;
+
+bool isProcessForkedChild()
+{
+   return getpid() != s_loadPid;
+}
+#else
+bool isProcessForkedChild()
+{
+   return false;
+}
+#endif
+
+} // namespace RcppParallel
+
 /* .Call calls */
 extern "C" SEXP defaultNumThreads();
 
+extern "C" SEXP isProcessForkedChild()
+{
+   int forked = RcppParallel::isProcessForkedChild() ? TRUE : FALSE;
+   return Rf_ScalarLogical(forked);
+}
+
 static const R_CallMethodDef CallEntries[] = {
-   {"defaultNumThreads", (DL_FUNC) &defaultNumThreads, 0},
+   {"defaultNumThreads",    (DL_FUNC) &defaultNumThreads,    0},
+   {"isProcessForkedChild", (DL_FUNC) &isProcessForkedChild, 0},
    {NULL, NULL, 0}
 };
 
 extern "C" void R_init_RcppParallel(DllInfo *dll)
 {
+#ifndef _WIN32
+   RcppParallel::s_loadPid = getpid();
+#endif
+
    R_registerRoutines(dll, NULL, CallEntries, NULL, NULL);
    R_useDynamicSymbols(dll, FALSE);
 }