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().

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(isForkedChild)
 export(setThreadOptions)
 export(tbbLibraryPath)

NEWS.md

@@ -1,6 +1,13 @@
 
 ## RcppParallel 6.0.0  (UNRELEASED)
 
+* RcppParallel now provides `isForkedChild()` (R) and
+  `RcppParallel::isForkedChild()` (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 `isForkedChild()` 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)
+#' isForkedChild()
+#' parallel::mclapply(1:2, function(i) RcppParallel::isForkedChild())
+#' }
+#'
+#' @export
+isForkedChild <- function() {
+   .Call("isForkedChild", 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 isForkedChild();
+
+} // namespace RcppParallel
+
+#endif // __RCPP_PARALLEL_FORK__

man/isForkedChild.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 isForkedChild()
+{
+   return getpid() != s_loadPid;
+}
+#else
+bool isForkedChild()
+{
+   return false;
+}
+#endif
+
+} // namespace RcppParallel
+
 /* .Call calls */
 extern "C" SEXP defaultNumThreads();
 
+extern "C" SEXP isForkedChild()
+{
+   int forked = RcppParallel::isForkedChild() ? TRUE : FALSE;
+   return Rf_ScalarLogical(forked);
+}
+
 static const R_CallMethodDef CallEntries[] = {
    {"defaultNumThreads", (DL_FUNC) &defaultNumThreads, 0},
+   {"isForkedChild",     (DL_FUNC) &isForkedChild,     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);
 }