Merge exception-safe array::resize_and_reset

Previously arrays were resized before reallocating memory, now the order is reversed,
which means that if an allocation exception is caught, the array is still unchanged.

Related PR: #1963

Author: upsj

core/test/base/array.cpp

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: BSD-3-Clause
 
 #include <algorithm>
+#include <stdexcept>
 #include <type_traits>
 
 #include <gtest/gtest.h>
@@ -36,7 +37,7 @@ class Array : public ::testing::Test {
         EXPECT_EQ(a.get_const_data()[1], T{2});
     }
 
-    std::shared_ptr<const gko::Executor> exec;
+    std::shared_ptr<gko::Executor> exec;
     gko::array<T> x;
 };
 
@@ -431,6 +432,37 @@ TYPED_TEST(Array, CanBeResized)
 }
 
 
+class ThrowOnAllocationLogger : public gko::log::Logger {
+public:
+    void on_allocation_started(const gko::Executor* exec,
+                               const gko::size_type& num_bytes) const override
+    {
+        throw std::runtime_error{""};
+    }
+
+    ThrowOnAllocationLogger()
+        : Logger(gko::log::Logger::allocation_started_mask)
+    {}
+};
+
+
+TYPED_TEST(Array, ResizeIsExceptionSafe)
+{
+    this->exec->add_logger(std::make_unique<ThrowOnAllocationLogger>());
+    gko::array<TypeParam> a{this->exec};
+    bool thrown = false;
+
+    try {
+        a.resize_and_reset(1);
+    } catch (const std::runtime_error&) {
+        thrown = true;
+    }
+
+    ASSERT_EQ(a.get_size(), 0);
+    ASSERT_TRUE(thrown);
+}
+
+
 TYPED_TEST(Array, ViewCannotBeResized)
 {
     TypeParam data[] = {1, 2, 3};

include/ginkgo/core/base/array.hpp

@@ -634,8 +634,8 @@ class array {
         }
 
         if (size > 0 && this->is_owning()) {
-            size_ = size;
             data_.reset(exec_->alloc<value_type>(size));
+            size_ = size;
         } else {
             this->clear();
         }