build the bundled onetbb on windows when rtools has no onetbb

Rtools42 ships Intel TBB 2017, and configure adopted it purely on the
presence of a libtbb* archive. Downstream packages then compiled against
those headers, which is not viable: StanHeaders uses
tbb::this_task_arena::isolate unconditionally, TBB 2017 still gates it
behind TBB_PREVIEW_TASK_ISOLATION, and its library doesn't export
isolate_within_arena, so forcing the declaration into view wouldn't link
either. rstan 2.32.7 consequently stopped building on R 4.2 / Windows.

Only adopt the Rtools TBB when it is oneTBB, and otherwise build the
bundled copy from sources, as we already do elsewhere. Rtools42 provides
cmake 3.24.1 in the same directory as gcc, so this needs no new tooling.
It is built as a static library so that RcppParallel.dll takes exactly the
shape it does with an Rtools oneTBB -- oneTBB marks its entry points
__declspec(dllexport) on mingw, so the whole-archive re-export of tbbmalloc
carries over unchanged.

Toolchains that can build neither (e.g. Rtools40, which has no TBB and no
cmake) still fall back to tinythread: a missing or too-old cmake is only an
error off Windows, where the bundled build is the sole option.

Also add CI covering this. R CMD check gains an R 4.2 Windows job, and a new
'downstream' job compiles and loads a translation unit against the flags
RcppParallel advertises, exercising both this_task_arena::isolate and
task_scheduler_observer. R CMD check alone would not have caught the rstan
breakage: RcppParallel installed perfectly well throughout.

Author: kevinushey

.github/scripts/tbb-downstream-check.R

@@ -0,0 +1,106 @@
+# Build and load a translation unit exercising the parts of the TBB API that
+# downstream packages depend on, using only the flags RcppParallel advertises.
+#
+# StanHeaders -- and so rstan -- needs both of the pieces used here:
+# tbb::this_task_arena::isolate, to keep its thread-local AD tape from being
+# modified by a task from another arena, and tbb::task_scheduler_observer, to
+# install that tape on each worker. Rtools42's TBB 2017 provides neither in a
+# usable form, which is what broke rstan on R 4.2 (isolate is gated behind
+# TBB_PREVIEW_TASK_ISOLATION, and isolate_within_arena isn't in the library at
+# all), so this stands in for a full rstan build.
+
+code <- '
+#include <tbb/blocked_range.h>
+#include <tbb/parallel_for.h>
+#include <tbb/task_arena.h>
+#include <tbb/task_scheduler_observer.h>
+
+#include <atomic>
+#include <cstddef>
+
+// R.h remaps names like \'length\' onto Rf_ equivalents by default, which
+// collides with the standard library; keep it last, and unremapped
+#define R_NO_REMAP
+#include <R.h>
+#include <Rinternals.h>
+
+namespace {
+
+// mirrors StanHeaders\' ad_tape_observer, which is what pulls the
+// task_scheduler_observer entry points into the link
+struct observer : public tbb::task_scheduler_observer {
+   observer() : tbb::task_scheduler_observer() { observe(true); }
+   void on_scheduler_entry(bool) override {}
+   void on_scheduler_exit(bool) override {}
+};
+
+} // end anonymous namespace
+
+extern "C" SEXP tbb_downstream_check(void) {
+
+   observer obs;
+   std::atomic<int> total(0);
+
+   // mirrors StanHeaders\' use of task isolation in reduce_sum / map_rect
+   tbb::this_task_arena::isolate([&] {
+      tbb::parallel_for(
+         tbb::blocked_range<std::size_t>(0, 1024),
+         [&](const tbb::blocked_range<std::size_t>& range) {
+            total += static_cast<int>(range.end() - range.begin());
+         }
+      );
+   });
+
+   return Rf_ScalarInteger(total.load());
+
+}
+'
+
+# report how RcppParallel is configured, so a failure here can be read
+# against the provenance logged during installation
+writeLines(c(
+   sprintf("TBB_ENABLED : %s", RcppParallel:::TBB_ENABLED),
+   sprintf("TBB_LIB     : '%s'", RcppParallel:::TBB_LIB),
+   sprintf("TBB_INC     : '%s'", RcppParallel:::TBB_INC),
+   sprintf("CxxFlags()  : %s", RcppParallel:::tbbCxxFlags()),
+   sprintf("LdFlags()   : %s", RcppParallel:::tbbLdFlags())
+))
+
+if (!RcppParallel:::TBB_ENABLED)
+   stop("RcppParallel was installed without a tbb backend")
+
+# mirror rstan's src/Makevars.win, which takes all of its TBB configuration
+# from RcppParallel: its compiler flags via CxxFlags(), its linker flags via
+# RcppParallelLibs(), and the include path itself via 'LinkingTo'
+makevars <- c(
+   "CXX_STD = CXX17",
+   sprintf("PKG_CPPFLAGS = -I\"%s\"", system.file("include", package = "RcppParallel")),
+   "PKG_CPPFLAGS += $(shell \"${R_HOME}/bin/Rscript\" -e \"RcppParallel::CxxFlags()\" | tail -n 1)",
+   "PKG_LIBS += $(shell \"${R_HOME}/bin${R_ARCH_BIN}/Rscript\" -e \"RcppParallel::RcppParallelLibs()\" | tail -n 1)"
+)
+
+dir <- tempfile("tbb-downstream-")
+dir.create(dir, recursive = TRUE)
+owd <- setwd(dir)
+on.exit(setwd(owd), add = TRUE)
+
+writeLines(code, "check.cpp")
+
+# deliberately not named 'Makevars': R CMD SHLIB reads a Makevars in the
+# working directory as well as R_MAKEVARS_USER, and would apply both. going
+# through R_MAKEVARS_USER also keeps any personal ~/.R/Makevars out of the way
+writeLines(makevars, "makevars-downstream")
+Sys.setenv(R_MAKEVARS_USER = file.path(dir, "makevars-downstream"))
+status <- system(paste(shQuote(file.path(R.home("bin"), "R")), "CMD SHLIB check.cpp"))
+if (status != 0L)
+   stop("downstream translation unit failed to build")
+
+# loading also proves any load-time dependency on the tbb stub resolves
+dll <- dyn.load(paste0("check", .Platform$dynlib.ext))
+on.exit(dyn.unload(dll[["path"]]), add = TRUE)
+
+result <- .Call("tbb_downstream_check")
+if (!identical(result, 1024L))
+   stop("downstream check returned ", result, "; expected 1024")
+
+writeLines("** downstream TBB check passed")

.github/workflows/R-CMD-check.yaml

@@ -23,6 +23,9 @@ jobs:
           - {os: ubuntu-24.04-arm, r: 'release'}
           - {os: windows-latest,   r: 'release'}
           - {os: windows-11-arm,   r: 'release'}
+          # Rtools42 provides only a pre-oneTBB copy of TBB, so this is the
+          # one configuration that builds the bundled oneTBB on Windows
+          - {os: windows-latest,   r: '4.2'}
 
     env:
       GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
@@ -32,6 +35,7 @@ jobs:
 
       - uses: r-lib/actions/setup-r@v2
         with:
+          r-version: ${{ matrix.config.r }}
           use-public-rspm: true
 
       - uses: r-lib/actions/setup-r-dependencies@v2
@@ -40,3 +44,35 @@ jobs:
           needs: check
 
       - uses: r-lib/actions/check-r-package@v2
+
+  # Verify that a package can still compile and link against the TBB API that
+  # RcppParallel advertises. This is the contract rstan (via StanHeaders)
+  # depends on, and it is not covered by R CMD check: RcppParallel can install
+  # perfectly well while leaving downstream packages unable to build.
+  downstream:
+    runs-on: windows-latest
+
+    name: downstream (${{ matrix.r }})
+
+    strategy:
+      fail-fast: false
+      matrix:
+        r: ['4.2', 'release']
+
+    env:
+      GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
+      VERBOSE: 1
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: r-lib/actions/setup-r@v2
+        with:
+          r-version: ${{ matrix.r }}
+          use-public-rspm: true
+
+      - name: install RcppParallel
+        run: R CMD INSTALL --preclean .
+
+      - name: build against RcppParallel
+        run: Rscript .github/scripts/tbb-downstream-check.R

src/install.libs.R

@@ -109,6 +109,12 @@ buildTbbStub <- function(tbbDest) {
    if (!nzchar(tbbInc))
       tbbInc <- TBB_INC
 
+   # when TBB was built from the bundled sources there is no TBB_INC to
+   # consult; its headers were copied into the package's include directory
+   # during the build, so dispatch on those instead
+   if (!nzchar(tbbInc))
+      tbbInc <- "../inst/include"
+
    if (file.exists(file.path(tbbInc, "oneapi"))) {
 
       # with oneTBB, the stub provides the old TBB ABI's
@@ -374,6 +380,19 @@ useBundledTbb <- function() {
       )
    }
 
+   # on Windows, build TBB as a static library: it then gets linked into
+   # (and re-exported from) RcppParallel.dll, giving the same layout we
+   # produce with an Rtools-provided oneTBB. the generator has to be named
+   # explicitly, as cmake otherwise prefers a Visual Studio generator when
+   # one happens to be installed
+   if (.Platform$OS.type == "windows") {
+      cmakeFlags <- c(
+         "-G", "MSYS Makefiles",
+         "-DBUILD_SHARED_LIBS=0",
+         cmakeFlags
+      )
+   }
+
    writeLines("*** configuring tbb")
    owd <- setwd("tbb/build-tbb")
    output <- system2(cmake, shQuote(cmakeFlags), stdout = TRUE, stderr = TRUE)
@@ -403,16 +422,14 @@ useBundledTbb <- function() {
    }
    setwd(owd)
 
-   shlibPattern <- switch(
-      Sys.info()[["sysname"]],
-      Windows = "^tbb.*\\.dll$",
-      Darwin  = "^libtbb.*\\.dylib$",
+   # on Windows (as on wasm) TBB is built as a static library, so collect
+   # the archives rather than the runtime libraries
+   shlibPattern <- if (.Platform$OS.type == "windows" || R.version$os == "emscripten") {
+      "^libtbb.*\\.a$"
+   } else if (Sys.info()[["sysname"]] == "Darwin") {
+      "^libtbb.*\\.dylib$"
+   } else {
       "^libtbb.*\\.so.*$"
-   )
-
-   # WASM only supports static libraries
-   if (R.version$os == "emscripten") {
-      shlibPattern <- "^libtbb.*\\.a$"
    }
 
    tbbFiles <- list.files(
@@ -534,7 +551,8 @@ args <- commandArgs(trailingOnly = TRUE)
 if (identical(args, "build")) {
    if (nzchar(tbbLib) && nzchar(tbbInc)) {
       useSystemTbb(tbbLib, tbbInc)
-   } else if (.Platform$OS.type == "windows") {
+   } else if (.Platform$OS.type == "windows" && !nzchar(Sys.getenv("CMAKE"))) {
+      # configure found neither a usable TBB nor a cmake to build one with
       writeLines("** building RcppParallel without tbb backend")
    } else {
       useBundledTbb()