autodiffstackstorage.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_REV_CORE_AUTODIFFSTACKSTORAGE_HPP
#define STAN_MATH_REV_CORE_AUTODIFFSTACKSTORAGE_HPP
 
#include <stan/math/memory/stack_alloc.hpp>
#include <vector>
 
namespace stan {
namespace math {
 
// Internal macro used to modify global pointer definition to the
// global AD instance.
#ifdef STAN_THREADS
// Whenever STAN_THREADS is set a TLS keyword is used. For reasons
// explained below we use the GNU compiler extension __thread if
// supported by the compiler while the generic thread_local C++11
// keyword is used otherwise.
#ifdef __GNUC__
#define STAN_THREADS_DEF __thread
#else
#define STAN_THREADS_DEF thread_local
#endif
#else
// In case STAN_THREADS is not set, then no modifier is needed.
#define STAN_THREADS_DEF
#endif
 
template <typename ChainableT, typename ChainableAllocT>
struct AutodiffStackSingleton {
  using AutodiffStackSingleton_t
      = AutodiffStackSingleton<ChainableT, ChainableAllocT>;
 
  AutodiffStackSingleton() : own_instance_(init()) {}
  ~AutodiffStackSingleton() {
    if (own_instance_) {
      delete instance_;
      instance_ = nullptr;
    }
  }
 
  struct AutodiffStackStorage {
    AutodiffStackStorage &operator=(const AutodiffStackStorage &) = delete;
 
    std::vector<ChainableT *> var_stack_;
    std::vector<ChainableT *> var_nochain_stack_;
    std::vector<ChainableAllocT *> var_alloc_stack_;
    stack_alloc memalloc_;
 
    // nested positions
    std::vector<size_t> nested_var_stack_sizes_;
    std::vector<size_t> nested_var_nochain_stack_sizes_;
    std::vector<size_t> nested_var_alloc_stack_starts_;
 
    STAN_STRONG_INLINE void push_var_stack(ChainableT *vi) {
      push(var_stack_, vi);
    }
    STAN_STRONG_INLINE void push_var_nochain_stack(ChainableT *vi) {
      push(var_nochain_stack_, vi);
    }
 
    STAN_STRONG_INLINE STAN_HOT_PATH static void push(
        std::vector<ChainableT *> &stack, ChainableT *vi) {
      if (likely(stack.size() != stack.capacity())) {
        stack.push_back(vi);
      } else {
        grow_and_push(stack, vi);
      }
    }
    STAN_COLD_PATH static void grow_and_push(std::vector<ChainableT *> &stack,
                                             ChainableT *vi) {
      stack.push_back(vi);
    }
  };
 
  explicit AutodiffStackSingleton(AutodiffStackSingleton_t const &) = delete;
  AutodiffStackSingleton &operator=(const AutodiffStackSingleton_t &) = delete;
 
  static STAN_THREADS_DEF AutodiffStackStorage *instance_;
 
 private:
  static bool init() {
    static STAN_THREADS_DEF bool is_initialized = false;
    if (!is_initialized) {
      is_initialized = true;
      instance_ = new AutodiffStackStorage();
      return true;
    }
    if (!instance_) {
      is_initialized = true;
      instance_ = new AutodiffStackStorage();
      return true;
    }
    return false;
  }
 
  bool own_instance_;
};
 
template <typename ChainableT, typename ChainableAllocT>
STAN_THREADS_DEF
    typename AutodiffStackSingleton<ChainableT,
                                    ChainableAllocT>::AutodiffStackStorage
        *AutodiffStackSingleton<ChainableT, ChainableAllocT>::instance_;
 
}  // namespace math
}  // namespace stan
#endif