change hard_copy to deep_copy, fix async logic in setZero() for matrix_cl, and add test for nan var matrix behaviors

Author: SteveBronder

stan/math/opencl/matrix_cl.hpp

@@ -509,7 +509,6 @@ class matrix_cl : public matrix_cl_base {
       return;
     }
     cl::Event zero_event;
-    this->wait_for_read_write_events();
     const std::size_t write_events_size = this->write_events().size();
     const std::size_t read_events_size = this->read_events().size();
     const std::size_t read_write_size = write_events_size + read_events_size;

stan/math/rev/core/arena_matrix.hpp

@@ -134,7 +134,7 @@ class arena_matrix : public Eigen::Map<MatrixType> {
    * @param x the values to write to `this`
    */
   template <typename T>
-  void hard_copy(const T& x) {
+  void deep_copy(const T& x) {
     Base::operator=(x);
   }
 };

stan/math/rev/core/var.hpp

@@ -1052,20 +1052,20 @@ class var_value<T, internal::require_matrix_var_value<T>> {
       return *this;
     }
     arena_t<plain_type_t<T>> prev_val(vi_->val_.rows(), vi_->val_.cols());
-    prev_val.hard_copy(vi_->val_);
-    vi_->val_.hard_copy(other.val());
+    prev_val.deep_copy(vi_->val_);
+    vi_->val_.deep_copy(other.val());
     // no need to change any adjoints - these are just zeros before the reverse
     // pass
 
     reverse_pass_callback(
         [this_vi = this->vi_, other_vi = other.vi_, prev_val]() mutable {
-          this_vi->val_.hard_copy(prev_val);
+          this_vi->val_.deep_copy(prev_val);
 
           // we have no way of detecting aliasing between this->vi_->adj_ and
           // other.vi_->adj_, so we must copy adjoint before reseting to zero
 
           // we can reuse prev_val instead of allocating a new matrix
-          prev_val.hard_copy(this_vi->adj_);
+          prev_val.deep_copy(this_vi->adj_);
           this_vi->adj_.setZero();
           other_vi->adj_ += prev_val;
         });
@@ -1074,13 +1074,15 @@ class var_value<T, internal::require_matrix_var_value<T>> {
   /**
    * Assignment of another var value, when either both `this` or other does not
    * contain a plain type.
+   * @note Here we do not need to use `deep_copy` as the `var_value`'s
+   * inner `vari_type` holds a view which will call the assignment operator
+   *  that does not perform a placement new.
    * @tparam S type of the value in the `var_value` to assign
    * @param other the value to assign
    * @return this
    */
   template <typename S, typename T_ = T,
             require_assignable_t<value_type, S>* = nullptr,
-            require_any_not_plain_type_t<T_, S>* = nullptr,
             require_not_plain_type_t<T_>* = nullptr>
   inline var_value<T>& operator=(const var_value<S>& other) {
     // If vi_ is nullptr then the var needs initialized via copy constructor
@@ -1105,7 +1107,7 @@ class var_value<T, internal::require_matrix_var_value<T>> {
           // other.vi_->adj_, so we must copy adjoint before reseting to zero
 
           // we can reuse prev_val instead of allocating a new matrix
-          prev_val.hard_copy(this_vi->adj_);
+          prev_val = this_vi->adj_;
           this_vi->adj_.setZero();
           other_vi->adj_ += prev_val;
         });

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

@@ -911,7 +911,7 @@ TEST_F(AgradRev, matrix_compile_time_conversions) {
   EXPECT_MATRIX_FLOAT_EQ(x11.val(), rowvec.val());
 }
 
-TEST_F(AgradRev, assign_nan) {
+TEST_F(AgradRev, assign_nan_varmat) {
   using stan::math::var_value;
   using var_vector = var_value<Eigen::Matrix<double, -1, 1>>;
   using stan::math::var;
@@ -935,6 +935,32 @@ TEST_F(AgradRev, assign_nan) {
   EXPECT_MATRIX_EQ(y_ans_adj, y.adj());
 }
 
+TEST_F(AgradRev, assign_nan_matvar) {
+  using stan::math::var;
+  using var_vector = Eigen::Matrix<var, -1, 1>;
+  Eigen::VectorXd x_val(10);
+  for (int i = 0; i < 10; ++i) {
+    x_val(i) = i + 0.1;
+  }
+  var_vector x(x_val);
+  var_vector y = var_vector(Eigen::Matrix<double, -1, 1>::Constant(
+      10, std::numeric_limits<double>::quiet_NaN()));
+  // need to store y's previous vari pointers
+  var_vector z = y;
+  y = stan::math::head(x, 10);
+  var sigma = 1.0;
+  var lp = stan::math::normal_lpdf<false>(y, 0, sigma);
+  lp.grad();
+  Eigen::VectorXd x_ans_adj(10);
+  for (int i = 0; i < 10; ++i) {
+    x_ans_adj(i) = -(i + 0.1);
+  }
+  EXPECT_MATRIX_EQ(x.adj(), x_ans_adj);
+  Eigen::VectorXd z_ans_adj = Eigen::VectorXd::Zero(10);
+  EXPECT_MATRIX_EQ(z_ans_adj, z.adj());
+}
+
+
 TEST_F(AgradRev, assign_nullptr_vari) {
   using stan::math::var_value;
   using var_vector = var_value<Eigen::Matrix<double, -1, 1>>;