use global control to set stack size

Author: kevinushey

inst/include/RcppParallel.h

@@ -28,37 +28,6 @@
 
 namespace RcppParallel {
 
-namespace {
-
-template <typename T, typename U>
-int resolveValue(const char* envvar,
-                 T requestedValue,
-                 U defaultValue)
-{
-   // if the requested value is non-zero and not the default, we can use it
-   if (requestedValue != defaultValue && requestedValue > 0)
-      return requestedValue;
-   
-   // otherwise, try reading the default from associated envvar
-   // if the environment variable is unset, use the default
-   const char* var = getenv(envvar);
-   if (var == NULL)
-      return defaultValue;
-   
-   // try to convert the string to a number
-   // if an error occurs during conversion, just use default
-   errno = 0;
-   char* end;
-   long value = strtol(var, &end, 10);
-   if (errno != 0)
-      return defaultValue;
-
-   // okay, return the parsed environment variable value   
-   return value;
-}
-
-} // end anonymous namespace
-
 inline void parallelFor(std::size_t begin,
                         std::size_t end, 
                         Worker& worker,

inst/include/RcppParallel/Common.h

@@ -1,10 +1,41 @@
 #ifndef __RCPP_PARALLEL_COMMON__
 #define __RCPP_PARALLEL_COMMON__
 
+#include <cerrno>
 #include <cstddef>
+#include <cstdlib>
 
 namespace RcppParallel {
 
+template <typename T, typename U>
+inline int resolveValue(const char* envvar,
+                        T requestedValue,
+                        U defaultValue)
+{
+   // if the requested value is non-zero and not the default, we can use it
+   if (requestedValue != defaultValue && requestedValue > 0)
+      return requestedValue;
+   
+   // otherwise, try reading the default from associated envvar
+   // if the environment variable is unset, use the default
+   const char* var = getenv(envvar);
+   if (var == NULL)
+      return defaultValue;
+   
+   // try to convert the string to a number
+   // if an error occurs during conversion, just use default
+   errno = 0;
+   char* end;
+   long value = strtol(var, &end, 10);
+   
+   // check for conversion failure
+   if (end == var || *end != '\0' || errno == ERANGE)
+      return defaultValue;
+   
+   // okay, return the parsed environment variable value   
+   return value;
+}
+
 // Work executed within a background thread. We implement dynamic
 // dispatch using vtables so we can have a stable type to cast
 // to from the void* passed to the worker thread (required because

inst/include/RcppParallel/TBB.h

@@ -3,7 +3,12 @@
 
 #include "Common.h"
 
+#ifndef TBB_PREVIEW_GLOBAL_CONTROL
+# define TBB_PREVIEW_GLOBAL_CONTROL 1
+#endif
+
 #include <tbb/tbb.h>
+#include <tbb/global_control.h>
 #include <tbb/scalable_allocator.h>
 
 namespace RcppParallel {
@@ -178,6 +183,43 @@ class TBBArenaParallelReduceExecutor
    std::size_t end_;
    std::size_t grainSize_;
 };
+
+class ThreadStackSizeControl
+{
+public:
+   
+   ThreadStackSizeControl()
+      : control_(nullptr)
+   {
+      int stackSize = resolveValue("RCPP_PARALLEL_STACK_SIZE", 0, 0);
+      if (stackSize > 0)
+      {
+         control_ = new tbb::global_control(
+            tbb::global_control::thread_stack_size,
+            stackSize
+         );
+      }
+   }
+   
+   ~ThreadStackSizeControl()
+   {
+      if (control_ != nullptr)
+      {
+         delete control_;
+         control_ = nullptr;
+      }
+   }
+
+private:
+   
+   // COPYING: not copyable
+   ThreadStackSizeControl(const ThreadStackSizeControl&);
+   ThreadStackSizeControl& operator=(const ThreadStackSizeControl&);
+   
+   // private members
+   tbb::global_control* control_;
+   
+};
 
 } // anonymous namespace
 
@@ -188,6 +230,8 @@ inline void tbbParallelFor(std::size_t begin,
                            std::size_t grainSize = 1,
                            int numThreads = tbb::task_arena::automatic)
 {
+   ThreadStackSizeControl control;
+   
    tbb::task_arena arena(numThreads);
    tbb::task_group group;
 
@@ -202,6 +246,8 @@ inline void tbbParallelReduce(std::size_t begin,
                               std::size_t grainSize = 1,
                               int numThreads = tbb::task_arena::automatic)
 {
+   ThreadStackSizeControl control;
+   
    tbb::task_arena arena(numThreads);
    tbb::task_group group;