make explicit use of pointer to AD tape for faster access without relying on compiler optimizations

Author: wds15

stan/math/rev/arr/fun/sum.hpp

@@ -29,7 +29,7 @@ class sum_v_vari : public vari {
 
   explicit sum_v_vari(const std::vector<var>& v1)
       : vari(sum_of_val(v1)),
-        v_(reinterpret_cast<vari**>(ChainableStack::instance().memalloc_.alloc(
+        v_(reinterpret_cast<vari**>(ChainableStack::instance_->memalloc_.alloc(
             v1.size() * sizeof(vari*)))),
         length_(v1.size()) {
     for (size_t i = 0; i < length_; i++)

stan/math/rev/core/autodiffstackstorage.hpp

@@ -9,12 +9,10 @@ namespace math {
 
 /**
  * Provides a thread_local singleton if needed. Read warnings below!
- * With STAN_THREADS defined, the singleton is a thread_local static pointer
- * for performance reasons. When STAN_THREADS is not set, we have the old
- * static AD stack in the instance_ field because we saw odd performance
- * issues on the Mac Pro[4]. The rest of this commentary is specifically
- * talking about the design choices in the STAN_THREADS=true case.
- * When a TLS is used then initialization with
+ * For performance reasons the singleton is a global static pointer
+ * which is stored as thread local (TLS) if STAN_THREADS is
+ * defined. The use of a pointer is motivated by performance reasons
+ * for the threading case. When a TLS is used then initialization with
  * a constant expression is required for fast access to the TLS. As
  * the AD storage struct is non-POD it must be initialized as a
  * dynamic expression such that compilers will wrap any access to the
@@ -61,7 +59,6 @@ namespace math {
  * [2] https://github.com/stan-dev/math/pull/826
  * [3]
  * http://discourse.mc-stan.org/t/potentially-dropping-support-for-older-versions-of-apples-version-of-clang/3780/
- * [4] https://github.com/stan-dev/math/pull/1135
  */
 template <typename ChainableT, typename ChainableAllocT>
 struct AutodiffStackSingleton {
@@ -70,12 +67,10 @@ struct AutodiffStackSingleton {
 
   AutodiffStackSingleton() : own_instance_(init()) {}
   ~AutodiffStackSingleton() {
-#ifdef STAN_THREADS
     if (own_instance_) {
       delete instance_;
       instance_ = nullptr;
     }
-#endif
   }
 
   struct AutodiffStackStorage {
@@ -95,39 +90,25 @@ struct AutodiffStackSingleton {
   explicit AutodiffStackSingleton(AutodiffStackSingleton_t const &) = delete;
   AutodiffStackSingleton &operator=(const AutodiffStackSingleton_t &) = delete;
 
-  static constexpr inline AutodiffStackStorage &instance() {
-    return
+  static
 #ifdef STAN_THREADS
-        *
+#ifdef __GNUC__
+      __thread
+#else
+      thread_local
 #endif
-        instance_;
-  }
+#endif
+      AutodiffStackStorage *instance_;
 
  private:
   static bool init() {
-#ifdef STAN_THREADS
     if (!instance_) {
       instance_ = new AutodiffStackStorage();
       return true;
     }
-#endif
     return false;
   }
 
-  static
-#ifdef STAN_THREADS
-#ifdef __GNUC__
-      __thread
-#else
-      thread_local
-#endif
-#endif
-      AutodiffStackStorage
-#ifdef STAN_THREADS
-          *
-#endif
-              instance_;
-
   bool own_instance_;
 };
 
@@ -141,13 +122,8 @@ thread_local
 #endif
     typename AutodiffStackSingleton<ChainableT,
                                     ChainableAllocT>::AutodiffStackStorage
-
-#ifdef STAN_THREADS
         *AutodiffStackSingleton<ChainableT, ChainableAllocT>::instance_
     = nullptr;
-#else
-    AutodiffStackSingleton<ChainableT, ChainableAllocT>::instance_;
-#endif
 
 }  // namespace math
 }  // namespace stan

stan/math/rev/core/build_vari_array.hpp

@@ -20,7 +20,7 @@ namespace math {
 template <int R, int C>
 vari** build_vari_array(const Eigen::Matrix<var, R, C>& x) {
   vari** x_vi_
-      = ChainableStack::instance().memalloc_.alloc_array<vari*>(x.size());
+      = ChainableStack::instance_->memalloc_.alloc_array<vari*>(x.size());
   for (int i = 0; i < x.size(); ++i) {
     x_vi_[i] = x(i).vi_;
   }

stan/math/rev/core/chainable_alloc.hpp

@@ -16,7 +16,7 @@ namespace math {
 class chainable_alloc {
  public:
   chainable_alloc() {
-    ChainableStack::instance().var_alloc_stack_.push_back(this);
+    ChainableStack::instance_->var_alloc_stack_.push_back(this);
   }
   virtual ~chainable_alloc() {}
 };

stan/math/rev/core/empty_nested.hpp

@@ -10,7 +10,7 @@ namespace math {
  * Return true if there is no nested autodiff being executed.
  */
 static inline bool empty_nested() {
-  return ChainableStack::instance().nested_var_stack_sizes_.empty();
+  return ChainableStack::instance_->nested_var_stack_sizes_.empty();
 }
 
 }  // namespace math

stan/math/rev/core/gevv_vvv_vari.hpp

@@ -32,7 +32,7 @@ class gevv_vvv_vari : public vari {
         length_(length) {
     alpha_ = alpha->vi_;
     // TODO(carpenter): replace this with array alloc fun call
-    v1_ = reinterpret_cast<vari**>(ChainableStack::instance().memalloc_.alloc(
+    v1_ = reinterpret_cast<vari**>(ChainableStack::instance_->memalloc_.alloc(
         2 * length_ * sizeof(vari*)));
     v2_ = v1_ + length_;
     for (size_t i = 0; i < length_; i++)

stan/math/rev/core/grad.hpp

@@ -37,8 +37,8 @@ static void grad(vari* vi) {
 
   typedef std::vector<vari*>::reverse_iterator it_t;
   vi->init_dependent();
-  it_t begin = ChainableStack::instance().var_stack_.rbegin();
-  it_t end = empty_nested() ? ChainableStack::instance().var_stack_.rend()
+  it_t begin = ChainableStack::instance_->var_stack_.rbegin();
+  it_t end = empty_nested() ? ChainableStack::instance_->var_stack_.rend()
                             : begin + nested_size();
   for (it_t it = begin; it < end; ++it) {
     (*it)->chain();

stan/math/rev/core/nested_size.hpp

@@ -8,8 +8,8 @@ namespace stan {
 namespace math {
 
 static inline size_t nested_size() {
-  return ChainableStack::instance().var_stack_.size()
-         - ChainableStack::instance().nested_var_stack_sizes_.back();
+  return ChainableStack::instance_->var_stack_.size()
+         - ChainableStack::instance_->nested_var_stack_sizes_.back();
 }
 
 }  // namespace math

stan/math/rev/core/precomputed_gradients.hpp

@@ -52,9 +52,9 @@ class precomputed_gradients_vari : public vari {
                              const std::vector<double>& gradients)
       : vari(val),
         size_(vars.size()),
-        varis_(ChainableStack::instance().memalloc_.alloc_array<vari*>(
+        varis_(ChainableStack::instance_->memalloc_.alloc_array<vari*>(
             vars.size())),
-        gradients_(ChainableStack::instance().memalloc_.alloc_array<double>(
+        gradients_(ChainableStack::instance_->memalloc_.alloc_array<double>(
             vars.size())) {
     check_consistent_sizes("precomputed_gradients_vari", "vars", vars,
                            "gradients", gradients);

stan/math/rev/core/print_stack.hpp

@@ -18,14 +18,14 @@ namespace math {
  * @param o ostream to modify
  */
 inline void print_stack(std::ostream& o) {
-  o << "STACK, size=" << ChainableStack::instance().var_stack_.size()
+  o << "STACK, size=" << ChainableStack::instance_->var_stack_.size()
     << std::endl;
   // TODO(carpenter): this shouldn't need to be cast any more
-  for (size_t i = 0; i < ChainableStack::instance().var_stack_.size(); ++i)
-    o << i << "  " << ChainableStack::instance().var_stack_[i] << "  "
-      << (static_cast<vari*>(ChainableStack::instance().var_stack_[i]))->val_
+  for (size_t i = 0; i < ChainableStack::instance_->var_stack_.size(); ++i)
+    o << i << "  " << ChainableStack::instance_->var_stack_[i] << "  "
+      << (static_cast<vari*>(ChainableStack::instance_->var_stack_[i]))->val_
       << " : "
-      << (static_cast<vari*>(ChainableStack::instance().var_stack_[i]))->adj_
+      << (static_cast<vari*>(ChainableStack::instance_->var_stack_[i]))->adj_
       << std::endl;
 }