bundle old version of tbb for now

Author: kevinushey

R/aaa.R

@@ -1,6 +1,7 @@
 
 # stubs that get overridden via configure script
 TBB_ENABLED <- TRUE
+TBB_STATIC <- FALSE
 TBB_LIB  <- ""
 TBB_INC  <- ""
 

R/tbb-autodetected.R.in

@@ -1,5 +1,6 @@
 
 TBB_ENABLED <- @TBB_ENABLED@
+TBB_STATIC <- @TBB_STATIC@
 TBB_LIB  <- "@TBB_LIB@"
 TBB_INC  <- "@TBB_INC@"
 

R/tbb.R

@@ -57,14 +57,15 @@ tbbCxxFlags <- function() {
    if (!TBB_ENABLED)
       return("-DRCPP_PARALLEL_USE_TBB=0")
 
-   flags <- c("-DRCPP_PARALLEL_USE_TBB=1")
+   flags <- c(
+      "-DRCPP_PARALLEL_USE_TBB=1",
+      "-DTBB_INTERFACE_NEW"
+   )
 
    # TBB does not have assembly code for Windows ARM64
    # so we need to use compiler builtins
-   if (TBB_ENABLED && is_windows()) {
-      if (R.version$arch == "aarch64") {
-         flags <- c(flags, "-DTBB_USE_GCC_BUILTINS")
-      }
+   if (is_windows() && R.version$arch == "aarch64") {
+      flags <- c(flags, "-DTBB_USE_GCC_BUILTINS")
    }
 
    # if TBB_INC is set, apply those library paths
@@ -75,16 +76,7 @@ tbbCxxFlags <- function() {
 
    # add include path
    if (nzchar(tbbInc) && file.exists(tbbInc)) {
-      
-      # prefer new interface if version.h exists -- we keep this
-      # for compatibility with packages like StanHeaders, rstan
-      versionPath <- file.path(tbbInc, "tbb/version.h")
-      if (file.exists(versionPath))
-         flags <- c(flags, "-DTBB_INTERFACE_NEW")
-      
-      # now add the include path
       flags <- c(flags, paste0("-I", asBuildPath(tbbInc)))
-      
    }
 
    # return flags as string
@@ -95,16 +87,14 @@ tbbCxxFlags <- function() {
 # Return the linker flags required for TBB on this platform
 tbbLdFlags <- function() {
 
-   # on Windows, we statically link to oneTBB
-   if (is_windows()) {
-      
+   # handle static linking
+   if (TBB_STATIC) {
       libPath <- system.file("libs", package = "RcppParallel")
       if (nzchar(.Platform$r_arch))
          libPath <- file.path(libPath, .Platform$r_arch)
 
       ldFlags <- sprintf("-L%s -lRcppParallel", asBuildPath(libPath))
       return(ldFlags)
-      
    }
 
    # shortcut if TBB_LIB defined

R/zzz.R

@@ -27,24 +27,19 @@ loadTbbLibrary <- function(name) {
 
 .onLoad <- function(libname, pkgname) {
 
-   # on Windows, load RcppParallel first
-   if (.Platform$OS.type == "windows") {
+   if (TBB_STATIC) {
       .dllInfo <<- library.dynam("RcppParallel", pkgname, libname)
+      return()
    }
 
-   # load tbb, tbbmalloc
    .tbbDllInfo       <<- loadTbbLibrary("tbb")
    .tbbMallocDllInfo <<- loadTbbLibrary("tbbmalloc")
 
-   # load tbbmalloc_proxy, but only if requested
    useTbbMallocProxy <- Sys.getenv("RCPP_PARALLEL_USE_TBBMALLOC_PROXY", unset = "FALSE")
    if (useTbbMallocProxy %in% c("TRUE", "True", "true", "1"))
       .tbbMallocProxyDllInfo <<- loadTbbLibrary("tbbmalloc_proxy")
 
-   # load RcppParallel library if available
-   if (.Platform$OS.type != "windows") {
-      .dllInfo <<- library.dynam("RcppParallel", pkgname, libname)
-   }
+   .dllInfo <<- library.dynam("RcppParallel", pkgname, libname)
 
 }
 

src/Makevars.in

@@ -2,13 +2,16 @@
 CMAKE = @CMAKE@
 R = @R@
 
+TBB_ENABLED     = @TBB_ENABLED@
+TBB_STATIC      = @TBB_STATIC@
+TBB_SRC         = @TBB_SRC@
 TBB_LIB         = @TBB_LIB@
 TBB_INC         = @TBB_INC@
+
 TBB_NAME        = @TBB_NAME@
 TBB_MALLOC_NAME = @TBB_MALLOC_NAME@
 
 PKG_CPPFLAGS = @PKG_CPPFLAGS@
-PKG_CXXFLAGS = @PKG_CXXFLAGS@
 
 PKG_LIBS = @PKG_LIBS@ @PKG_LIBS_EXTRA@
 
@@ -21,11 +24,23 @@ $(OBJECTS): tbb
 # NOTE: TBB libraries are installed via install.libs.R.
 # However, we need to copy headers here so that they are visible during compilation.
 tbb: tbb-clean
-	@TBB_LIB="$(TBB_LIB)" TBB_INC="$(TBB_INC)"                  \
-	TBB_NAME="$(TBB_NAME)" TBB_MALLOC_NAME="$(TBB_MALLOC_NAME)" \
-	CC="$(CC)" CFLAGS="$(CFLAGS)" CPPFLAGS="$(CPPFLAGS)"        \
-	CXX="$(CXX)" CXXFLAGS="$(CXXFLAGS)"	LDFLAGS="$(LDFLAGS)"    \
-	CMAKE="$(CMAKE)" "@R@" -s -f install.libs.R --args build
+	@                                    \
+	TBB_ENABLED="$(TBB_ENABLED)"         \
+	TBB_STATIC="$(TBB_STATIC)"           \
+	TBB_SRC="$(TBB_SRC)"                 \
+	TBB_LIB="$(TBB_LIB)"                 \
+	TBB_INC="$(TBB_INC)"                 \
+	TBB_NAME="$(TBB_NAME)"               \
+	TBB_MALLOC_NAME="$(TBB_MALLOC_NAME)" \
+	CC="$(CC)"                           \
+	CFLAGS="$(CFLAGS)"                   \
+	CPPFLAGS="$(CPPFLAGS)"               \
+	CXX="$(CXX)"                         \
+	CXXFLAGS="$(CXXFLAGS)"	             \
+	CXXPICFLAGS="$(CXXPICFLAGS)"         \
+	LDFLAGS="$(LDFLAGS)"                 \
+	CMAKE="$(CMAKE)"                     \
+	"@R@" -s -f install.libs.R --args build
 
 # NOTE: we do not want to clean ../inst/lib or ../inst/libs here,
 # as we may be writing to those locations in multiarch builds

src/install.libs.R

@@ -105,6 +105,9 @@ useBundledTbb <- function() {
    cmake <- Sys.getenv("CMAKE", unset = "cmake")
    buildType <- Sys.getenv("CMAKE_BUILD_TYPE", unset = "Release")
    verbose <- Sys.getenv("VERBOSE", unset = "0")
+   
+   cxxFlags <- paste(Sys.getenv("CPPFLAGS", "CXXFLAGS", "CXXPICFLAGS"), collapse = " ")
+   Sys.setenv(CXXFLAGS = cxxFlags)
 
    cmakeFlags <- c(
       sprintf("-DCMAKE_BUILD_TYPE=%s", buildType),
@@ -159,20 +162,90 @@ useBundledTbb <- function() {
 
 }
 
+useOldBundledTbb <- function() {
+   
+   useTbbPreamble("tbb-2019/include")
+   owd <- setwd("tbb-2019/src")
+   on.exit(setwd(owd), add = TRUE)
+   
+   makeArgs <- "stdver=c++11"
+   cxxFlags <- c(
+      "-DTBB_NO_LEGACY=1",
+      "-DTBB_SUPPRESS_DEPRECATED_MESSAGES=1",
+      Sys.getenv(c("CPPFLAGS", "CXXFLAGS"))
+   )
+   
+   cxxFlags <- paste(cxxFlags, collapse = " ")
+   Sys.setenv(
+      CONLY    = Sys.getenv("CC", unset = "cc"),
+      CPLUS    = Sys.getenv("CXX", unset = "c++"),
+      CXXFLAGS = paste(cxxFlags, collapse = " "),
+      PIC_KEY  = Sys.getenv("CXXPICFLAGS", unset = "-fPIC"),
+      WARNING_SUPPRESS = ""
+   )
+   
+   if (.Platform$OS.type == "windows") {
+      
+      Sys.setenv(
+         MSYS2_ARG_CONV_EXCL = "*",
+         CYGWIN = "nodosfilewarning",
+         WINARM64_CLANG = "$(WINARM64_CLANG)"
+      )
+      
+      makeArgs <- "rtools=true compiler=gcc runtime=mingw"
+
+   }
+   
+   writeLines("** configuring tbb")
+   system("make info")
+   writeLines("")
+   
+   writeLines("** building tbb")
+   makeTargets <- c("tbb_build_prefix=lib", "tbb_release", "tbbmalloc_release")
+   output <- system2("make", c("-e", makeArgs, makeTargets), stdout = TRUE, stderr = TRUE)
+   status <- attr(output, "status")
+   if (!is.null(status) && status != 0) {
+      writeLines(output, con = stderr())
+      stop("error building tbb")
+   }
+   
+   shlibPattern <- switch(
+      Sys.info()[["sysname"]],
+      Windows = "^tbb.*\\.dll$",
+      Darwin  = "^libtbb.*\\.dylib$",
+      "^libtbb.*\\.so.*$"
+   )
+   
+   setwd(owd)
+   tbbFiles <- list.files(
+      file.path(getwd(), "tbb-2019/build/lib_release"),
+      pattern = shlibPattern,
+      recursive = TRUE,
+      full.names = TRUE
+   )
+   
+   dir.create("tbb/build/lib_release", recursive = TRUE, showWarnings = FALSE)
+   file.copy(tbbFiles, "tbb/build/lib_release", overwrite = TRUE)
+   unlink("tbb/build-tbb", recursive = TRUE)
+   writeLines("** finished building tbb")
+
+}
+
 
 # Main ----
 
+tbbSrc <- Sys.getenv("TBB_SRC")
 tbbLib <- Sys.getenv("TBB_LIB")
 tbbInc <- Sys.getenv("TBB_INC")
 
 args <- commandArgs(trailingOnly = TRUE)
 if (identical(args, "build")) {
    if (nzchar(tbbLib) && nzchar(tbbInc)) {
       useSystemTbb(tbbLib, tbbInc)
-   } else if (.Platform$OS.type == "windows") {
-      writeLines("** building RcppParallel without tbb backend")
-   } else {
+   } else if (tbbSrc == "tbb") {
       useBundledTbb()
+   } else if (tbbSrc == "tbb-2019") {
+      useOldBundledTbb()
    }
 } else {
    source("../R/tbb-autodetected.R")