avoid vari on chain-stack if var is constructed from an arithmetic type

stan/math/rev/core/var.hpp

@@ -79,7 +79,7 @@ class var {
    *
    * @param x Value of the variable.
    */
-  var(float x) : vi_(new vari(static_cast<double>(x))) {}  // NOLINT
+  var(float x) : vi_(new vari(static_cast<double>(x), false)) {}  // NOLINT
 
   /**
    * Construct a variable from the specified arithmetic argument
@@ -88,7 +88,7 @@ class var {
    *
    * @param x Value of the variable.
    */
-  var(double x) : vi_(new vari(x)) {}  // NOLINT
+  var(double x) : vi_(new vari(x, false)) {}  // NOLINT
 
   /**
    * Construct a variable from the specified arithmetic argument
@@ -97,7 +97,7 @@ class var {
    *
    * @param x Value of the variable.
    */
-  var(long double x) : vi_(new vari(x)) {}  // NOLINT
+  var(long double x) : vi_(new vari(x, false)) {}  // NOLINT
 
   /**
    * Construct a variable from the specified arithmetic argument
@@ -106,7 +106,7 @@ class var {
    *
    * @param x Value of the variable.
    */
-  var(bool x) : vi_(new vari(static_cast<double>(x))) {}  // NOLINT
+  var(bool x) : vi_(new vari(static_cast<double>(x), false)) {}  // NOLINT
 
   /**
    * Construct a variable from the specified arithmetic argument
@@ -115,7 +115,7 @@ class var {
    *
    * @param x Value of the variable.
    */
-  var(char x) : vi_(new vari(static_cast<double>(x))) {}  // NOLINT
+  var(char x) : vi_(new vari(static_cast<double>(x), false)) {}  // NOLINT
 
   /**
    * Construct a variable from the specified arithmetic argument
@@ -124,7 +124,7 @@ class var {
    *
    * @param x Value of the variable.
    */
-  var(short x) : vi_(new vari(static_cast<double>(x))) {}  // NOLINT
+  var(short x) : vi_(new vari(static_cast<double>(x), false)) {}  // NOLINT
 
   /**
    * Construct a variable from the specified arithmetic argument
@@ -133,7 +133,7 @@ class var {
    *
    * @param x Value of the variable.
    */
-  var(int x) : vi_(new vari(static_cast<double>(x))) {}  // NOLINT
+  var(int x) : vi_(new vari(static_cast<double>(x), false)) {}  // NOLINT
 
   /**
    * Construct a variable from the specified arithmetic argument
@@ -142,7 +142,7 @@ class var {
    *
    * @param x Value of the variable.
    */
-  var(long x) : vi_(new vari(static_cast<double>(x))) {}  // NOLINT
+  var(long x) : vi_(new vari(static_cast<double>(x), false)) {}  // NOLINT
 
   /**
    * Construct a variable from the specified arithmetic argument
@@ -152,7 +152,7 @@ class var {
    * @param x Value of the variable.
    */
   var(unsigned char x)  // NOLINT(runtime/explicit)
-      : vi_(new vari(static_cast<double>(x))) {}
+      : vi_(new vari(static_cast<double>(x), false)) {}
 
   /**
    * Construct a variable from the specified arithmetic argument
@@ -162,7 +162,7 @@ class var {
    * @param x Value of the variable.
    */
   // NOLINTNEXTLINE
-  var(unsigned short x) : vi_(new vari(static_cast<double>(x))) {}
+  var(unsigned short x) : vi_(new vari(static_cast<double>(x), false)) {}
 
   /**
    * Construct a variable from the specified arithmetic argument
@@ -171,7 +171,9 @@ class var {
    *
    * @param x Value of the variable.
    */
-  var(unsigned int x) : vi_(new vari(static_cast<double>(x))) {}  // NOLINT
+  // NOLINTNEXTLINE
+  var(unsigned int x)
+      : vi_(new vari(static_cast<double>(x), false)) {}  // NOLINT
 
   /**
    * Construct a variable from the specified arithmetic argument
@@ -181,7 +183,8 @@ class var {
    * @param x Value of the variable.
    */
   // NOLINTNEXTLINE
-  var(unsigned long x) : vi_(new vari(static_cast<double>(x))) {}  // NOLINT
+  var(unsigned long x)
+      : vi_(new vari(static_cast<double>(x), false)) {}  // NOLINT
 
   /**
    * Construct a variable from the specified arithmetic argument
@@ -193,7 +196,7 @@ class var {
    */
   explicit var(const std::complex<double>& x) {
     if (imag(x) == 0) {
-      vi_ = new vari(real(x));
+      vi_ = new vari(real(x), false);
     } else {
       std::stringstream ss;
       ss << "Imaginary part of std::complex used to construct var"
@@ -214,7 +217,7 @@ class var {
    */
   explicit var(const std::complex<float>& x) {
     if (imag(x) == 0) {
-      vi_ = new vari(static_cast<double>(real(x)));
+      vi_ = new vari(static_cast<double>(real(x)), false);
     } else {
       std::stringstream ss;
       ss << "Imaginary part of std::complex used to construct var"
@@ -235,7 +238,7 @@ class var {
    */
   explicit var(const std::complex<long double>& x) {
     if (imag(x) == 0) {
-      vi_ = new vari(static_cast<double>(real(x)));
+      vi_ = new vari(static_cast<double>(real(x)), false);
     } else {
       std::stringstream ss;
       ss << "Imaginary part of std::complex used to construct var"
@@ -259,7 +262,7 @@ class var {
    *
    * @param x Value of the variable.
    */
-  var(size_t x) : vi_(new vari(static_cast<double>(x))) {}  // NOLINT
+  var(size_t x) : vi_(new vari(static_cast<double>(x), false)) {}  // NOLINT
 
   /**
    * Construct a variable from the specified arithmetic argument
@@ -268,7 +271,7 @@ class var {
    *
    * @param x Value of the variable.
    */
-  var(ptrdiff_t x) : vi_(new vari(static_cast<double>(x))) {}  // NOLINT
+  var(ptrdiff_t x) : vi_(new vari(static_cast<double>(x), false)) {}  // NOLINT
 #endif
 
 #ifdef BOOST_MATH_USE_FLOAT128
@@ -283,7 +286,7 @@ class var {
    *
    * @param x Value of the variable.
    */
-  var(__float128 x) : vi_(new vari(static_cast<double>(x))) {}  // NOLINT
+  var(__float128 x) : vi_(new vari(static_cast<double>(x), false)) {}  // NOLINT
 
 #endif
 

stan/math/rev/functor/coupled_ode_system.hpp

@@ -119,10 +119,7 @@ struct coupled_ode_system<F, double, var> {
     try {
       start_nested();
 
-      vector<var> y_vars;
-      y_vars.reserve(N_);
-      for (std::size_t i = 0; i < N_; ++i)
-        y_vars.emplace_back(new vari(z[i], false));
+      vector<var> y_vars(z.begin(), z.begin() + N_);
 
       vector<var> dy_dt_vars = f_(t, y_vars, theta_nochain_, x_, x_int_, msgs_);
 
@@ -279,10 +276,7 @@ struct coupled_ode_system<F, var, double> {
     try {
       start_nested();
 
-      vector<var> y_vars;
-      y_vars.reserve(N_);
-      for (std::size_t i = 0; i < N_; ++i)
-        y_vars.emplace_back(new vari(z[i], false));
+      vector<var> y_vars(z.begin(), z.begin() + N_);
 
       vector<var> dy_dt_vars = f_(t, y_vars, theta_dbl_, x_, x_int_, msgs_);
 
@@ -460,10 +454,7 @@ struct coupled_ode_system<F, var, var> {
     try {
       start_nested();
 
-      vector<var> y_vars;
-      y_vars.reserve(N_);
-      for (std::size_t i = 0; i < N_; ++i)
-        y_vars.emplace_back(new vari(z[i], false));
+      vector<var> y_vars(z.begin(), z.begin() + N_);
 
       vector<var> dy_dt_vars = f_(t, y_vars, theta_nochain_, x_, x_int_, msgs_);
 

stan/math/rev/functor/gradient.hpp

@@ -43,9 +43,7 @@ void gradient(const F& f, const Eigen::Matrix<double, Eigen::Dynamic, 1>& x,
               double& fx, Eigen::Matrix<double, Eigen::Dynamic, 1>& grad_fx) {
   start_nested();
   try {
-    Eigen::Matrix<var, Eigen::Dynamic, 1> x_var(x.size());
-    for (int i = 0; i < x.size(); ++i)
-      x_var(i) = var(new vari(x(i), false));
+    Eigen::Matrix<var, Eigen::Dynamic, 1> x_var(x);
     var fx_var = f(x_var);
     fx = fx_var.val();
     grad_fx.resize(x.size());

test/unit/math/rev/core/thread_stack_instance_test.cpp

@@ -84,19 +84,23 @@ TEST(thread_stack_instance, child_instances) {
   // thread will be different at initialization (if STAN_THREADS is
   // set)
   stan::math::var a = 1;
+  stan::math::var b = a * a;
 
   ChainableStack::AutodiffStackStorage* main_ad_stack
       = ChainableStack::instance_;
 
   auto thread_tester = [&]() -> void {
     ChainableStack thread_instance;
-    EXPECT_TRUE(main_ad_stack->var_stack_.size()
+    EXPECT_TRUE(
+        main_ad_stack->var_stack_.size()
+            + stan::math::ChainableStack::instance_->var_nochain_stack_.size()
 #ifdef STAN_THREADS
-                >
+        >
 #else
-                ==
+        ==
 #endif
-                ChainableStack::instance_->var_stack_.size());
+        ChainableStack::instance_->var_stack_.size()
+            + stan::math::ChainableStack::instance_->var_nochain_stack_.size());
   };
 
   std::thread other_work(thread_tester);

test/unit/math/rev/err/check_bounded_test.cpp

@@ -15,13 +15,16 @@ TEST(AgradRevErrorHandlingScalar, CheckBoundedVarCheckVectorized) {
   for (int i = 0; i < N; ++i)
     a.push_back(var(i));
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(5U, stack_size);
   EXPECT_NO_THROW(check_bounded(function, "a", a, -1.0, 6.0));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(5U, stack_size_after_call);
   stan::math::recover_memory();
 }
@@ -145,13 +148,16 @@ TEST(AgradRevErrorHandlingScalar, CheckBoundedVarCheckUnivariate) {
   const char* function = "check_bounded";
   var a(5.0);
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(1U, stack_size);
   EXPECT_NO_THROW(check_bounded(function, "a", a, 4.0, 6.0));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(1U, stack_size_after_call);
 
   stan::math::recover_memory();

test/unit/math/rev/err/check_consistent_size_test.cpp

@@ -15,13 +15,16 @@ TEST(AgradRevErrorHandlingScalar, CheckConsistentSizeVarCheckVectorized) {
   for (int i = 0; i < N; ++i)
     a.push_back(var(i));
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(5U, stack_size);
   EXPECT_NO_THROW(check_consistent_size(function, "a", a, 5U));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(5U, stack_size_after_call);
   stan::math::recover_memory();
 }

test/unit/math/rev/err/check_consistent_sizes_test.cpp

@@ -17,13 +17,16 @@ TEST(AgradRevErrorHandlingScalar, CheckConsistentSizesVarCheckVectorized) {
     a.push_back(var(i));
   }
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(10U, stack_size);
   EXPECT_NO_THROW(check_consistent_sizes(function, "a", a, "b", b));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(10U, stack_size_after_call);
   stan::math::recover_memory();
 }

test/unit/math/rev/err/check_finite_test.cpp

@@ -15,19 +15,23 @@ TEST(AgradRevErrorHandlingScalar, CheckFiniteVarCheckVectorized) {
   for (int i = 0; i < N; ++i)
     a.push_back(var(i));
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(5U, stack_size);
   EXPECT_NO_THROW(check_finite(function, "a", a));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(5U, stack_size_after_call);
 
   a[1] = std::numeric_limits<double>::infinity();
   EXPECT_THROW(check_finite(function, "a", a), std::domain_error);
   stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(6U, stack_size_after_call);
 
   stan::math::recover_memory();
@@ -65,19 +69,23 @@ TEST(AgradRevErrorHandlingScalar, CheckFiniteVarCheckUnivariate) {
   const char* function = "check_finite";
   var a(5.0);
 
-  size_t stack_size = stan::math::ChainableStack::instance_->var_stack_.size();
+  size_t stack_size
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
 
   EXPECT_EQ(1U, stack_size);
   EXPECT_NO_THROW(check_finite(function, "a", a));
 
   size_t stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(1U, stack_size_after_call);
 
   a = std::numeric_limits<double>::infinity();
   EXPECT_THROW(check_finite(function, "a", a), std::domain_error);
   stack_size_after_call
-      = stan::math::ChainableStack::instance_->var_stack_.size();
+      = stan::math::ChainableStack::instance_->var_stack_.size()
+        + stan::math::ChainableStack::instance_->var_nochain_stack_.size();
   EXPECT_EQ(2U, stack_size_after_call);
 
   stan::math::recover_memory();