Merge adding move_from to PolymorphicObject

This PR adds a `move_from(PolymorphicObject*)` and `move_from(unique_ptr<PolymorphicObject>)` to `PolymorphicObject`. It also adds a corresponding logger event for this.

Related PR: #997

core/log/logger.cpp

@@ -59,6 +59,8 @@ constexpr Logger::mask_type Logger::polymorphic_object_create_started_mask;
 constexpr Logger::mask_type Logger::polymorphic_object_create_completed_mask;
 constexpr Logger::mask_type Logger::polymorphic_object_copy_started_mask;
 constexpr Logger::mask_type Logger::polymorphic_object_copy_completed_mask;
+constexpr Logger::mask_type Logger::polymorphic_object_move_started_mask;
+constexpr Logger::mask_type Logger::polymorphic_object_move_completed_mask;
 constexpr Logger::mask_type Logger::polymorphic_object_deleted_mask;
 
 constexpr Logger::mask_type Logger::linop_apply_started_mask;

core/log/papi.cpp

@@ -148,6 +148,24 @@ void Papi<ValueType>::on_polymorphic_object_copy_completed(
 }
 
 
+template <typename ValueType>
+void Papi<ValueType>::on_polymorphic_object_move_started(
+    const Executor* exec, const PolymorphicObject* from,
+    const PolymorphicObject* to) const
+{
+    polymorphic_object_move_started.get_counter(exec) += 1;
+}
+
+
+template <typename ValueType>
+void Papi<ValueType>::on_polymorphic_object_move_completed(
+    const Executor* exec, const PolymorphicObject* from,
+    const PolymorphicObject* to) const
+{
+    polymorphic_object_move_completed.get_counter(exec) += 1;
+}
+
+
 template <typename ValueType>
 void Papi<ValueType>::on_polymorphic_object_deleted(
     const Executor* exec, const PolymorphicObject* po) const

core/log/record.cpp

@@ -162,6 +162,24 @@ void Record::on_polymorphic_object_copy_completed(
 }
 
 
+void Record::on_polymorphic_object_move_started(
+    const Executor* exec, const PolymorphicObject* from,
+    const PolymorphicObject* to) const
+{
+    append_deque(data_.polymorphic_object_move_started,
+                 (std::make_unique<polymorphic_object_data>(exec, from, to)));
+}
+
+
+void Record::on_polymorphic_object_move_completed(
+    const Executor* exec, const PolymorphicObject* from,
+    const PolymorphicObject* to) const
+{
+    append_deque(data_.polymorphic_object_move_completed,
+                 (std::make_unique<polymorphic_object_data>(exec, from, to)));
+}
+
+
 void Record::on_polymorphic_object_deleted(const Executor* exec,
                                            const PolymorphicObject* po) const
 {

core/log/stream.cpp

@@ -245,6 +245,26 @@ void Stream<ValueType>::on_polymorphic_object_copy_completed(
 }
 
 
+template <typename ValueType>
+void Stream<ValueType>::on_polymorphic_object_move_started(
+    const Executor* exec, const PolymorphicObject* from,
+    const PolymorphicObject* to) const
+{
+    os_ << prefix_ << demangle_name(from) << " move started to "
+        << demangle_name(to) << " on " << demangle_name(exec) << std::endl;
+}
+
+
+template <typename ValueType>
+void Stream<ValueType>::on_polymorphic_object_move_completed(
+    const Executor* exec, const PolymorphicObject* from,
+    const PolymorphicObject* to) const
+{
+    os_ << prefix_ << demangle_name(from) << " move completed to "
+        << demangle_name(to) << " on " << demangle_name(exec) << std::endl;
+}
+
+
 template <typename ValueType>
 void Stream<ValueType>::on_polymorphic_object_deleted(
     const Executor* exec, const PolymorphicObject* po) const

core/test/base/polymorphic_object.cpp

@@ -46,6 +46,33 @@ struct DummyObject : gko::EnablePolymorphicObject<DummyObject>,
         : gko::EnablePolymorphicObject<DummyObject>(std::move(exec)), x{v}
     {}
 
+    DummyObject(const DummyObject& other) : DummyObject(other.get_executor())
+    {
+        *this = other;
+    }
+
+    DummyObject(DummyObject&& other) : DummyObject(other.get_executor())
+    {
+        *this = std::move(other);
+    }
+
+    DummyObject& operator=(const DummyObject& other)
+    {
+        if (this != &other) {
+            x = other.x;
+        }
+        return *this;
+    }
+
+    DummyObject& operator=(DummyObject&& other) noexcept
+    {
+        if (this != &other) {
+            x = std::exchange(other.x, 0);
+        }
+        return *this;
+    }
+
+
     int x;
 };
 
@@ -114,13 +141,41 @@ TEST_F(EnablePolymorphicObject, CopiesObject)
     ASSERT_NE(copy, obj);
     ASSERT_EQ(copy->get_executor(), omp);
     ASSERT_EQ(copy->x, 5);
+    ASSERT_EQ(obj->get_executor(), ref);
+    ASSERT_EQ(obj->x, 5);
+}
+
+
+TEST_F(EnablePolymorphicObject, MovesObjectByCopyFromUniquePtr)
+{
+    auto copy = DummyObject::create(ref, 7);
+
+    copy->copy_from(gko::give(obj));
+
+    ASSERT_NE(copy, obj);
+    ASSERT_EQ(copy->get_executor(), ref);
+    ASSERT_EQ(copy->x, 5);
 }
 
 
 TEST_F(EnablePolymorphicObject, MovesObject)
 {
     auto copy = DummyObject::create(ref, 7);
 
+    copy->move_from(gko::lend(obj));
+
+    ASSERT_NE(copy, obj);
+    ASSERT_EQ(copy->get_executor(), ref);
+    ASSERT_EQ(copy->x, 5);
+    ASSERT_EQ(obj->get_executor(), ref);
+    ASSERT_EQ(obj->x, 0);
+}
+
+
+TEST_F(EnablePolymorphicObject, MovesFromUniquePtr)
+{
+    auto copy = DummyObject::create(ref, 7);
+
     copy->copy_from(gko::give(obj));
 
     ASSERT_NE(copy, obj);

core/test/log/papi.cpp

@@ -338,6 +338,42 @@ TYPED_TEST(Papi, CatchesPolymorphicObjectCopyCompleted)
 }
 
 
+TYPED_TEST(Papi, CatchesPolymorphicObjectMoveStarted)
+{
+    auto str =
+        this->init(gko::log::Logger::polymorphic_object_move_started_mask,
+                   "polymorphic_object_move_started", this->exec.get());
+    this->add_event(str);
+
+    this->start();
+    this->logger
+        ->template on<gko::log::Logger::polymorphic_object_move_started>(
+            this->exec.get(), nullptr, nullptr);
+    long long int value = 0;
+    this->stop(&value);
+
+    ASSERT_EQ(value, 1);
+}
+
+
+TYPED_TEST(Papi, CatchesPolymorphicObjectMoveCompleted)
+{
+    auto str =
+        this->init(gko::log::Logger::polymorphic_object_move_completed_mask,
+                   "polymorphic_object_move_completed", this->exec.get());
+    this->add_event(str);
+
+    this->start();
+    this->logger
+        ->template on<gko::log::Logger::polymorphic_object_move_completed>(
+            this->exec.get(), nullptr, nullptr);
+    long long int value = 0;
+    this->stop(&value);
+
+    ASSERT_EQ(value, 1);
+}
+
+
 TYPED_TEST(Papi, CatchesPolymorphicObjectDeleted)
 {
     auto str = this->init(gko::log::Logger::polymorphic_object_deleted_mask,

core/test/log/record.cpp

@@ -285,6 +285,45 @@ TEST(Record, CatchesPolymorphicObjectCopyCompleted)
 }
 
 
+TEST(Record, CatchesPolymorphicObjectMoveStarted)
+{
+    using Dense = gko::matrix::Dense<>;
+    auto exec = gko::ReferenceExecutor::create();
+    auto logger = gko::log::Record::create(
+        exec, gko::log::Logger::polymorphic_object_move_started_mask);
+    auto from = gko::matrix::Dense<>::create(exec);
+    auto to = gko::matrix::Dense<>::create(exec);
+
+    logger->on<gko::log::Logger::polymorphic_object_move_started>(
+        exec.get(), from.get(), to.get());
+
+    auto& data = logger->get().polymorphic_object_move_started.back();
+    ASSERT_EQ(data->exec, exec.get());
+    GKO_ASSERT_MTX_NEAR(gko::as<Dense>(data->input.get()), from.get(), 0);
+    GKO_ASSERT_MTX_NEAR(gko::as<Dense>(data->output.get()), to.get(), 0);
+}
+
+
+TEST(Record, CatchesPolymorphicObjectMoveCompleted)
+{
+    using Dense = gko::matrix::Dense<>;
+    auto exec = gko::ReferenceExecutor::create();
+    auto logger = gko::log::Record::create(
+        exec, gko::log::Logger::polymorphic_object_move_completed_mask);
+    auto from = gko::matrix::Dense<>::create(exec);
+    auto to = gko::matrix::Dense<>::create(exec);
+
+    logger->on<gko::log::Logger::polymorphic_object_move_completed>(
+        exec.get(), from.get(), to.get());
+
+
+    auto& data = logger->get().polymorphic_object_move_completed.back();
+    ASSERT_EQ(data->exec, exec.get());
+    GKO_ASSERT_MTX_NEAR(gko::as<Dense>(data->input.get()), from.get(), 0);
+    GKO_ASSERT_MTX_NEAR(gko::as<Dense>(data->output.get()), to.get(), 0);
+}
+
+
 TEST(Record, CatchesPolymorphicObjectDeleted)
 {
     using Dense = gko::matrix::Dense<>;

core/test/log/stream.cpp

@@ -313,6 +313,52 @@ TYPED_TEST(Stream, CatchesPolymorphicObjectCopyCompleted)
 }
 
 
+TYPED_TEST(Stream, CatchesPolymorphicObjectMoveStarted)
+{
+    auto exec = gko::ReferenceExecutor::create();
+    std::stringstream out;
+    auto logger = gko::log::Stream<TypeParam>::create(
+        exec, gko::log::Logger::polymorphic_object_move_started_mask, out);
+    auto from = gko::matrix::Dense<TypeParam>::create(exec);
+    auto to = gko::matrix::Dense<TypeParam>::create(exec);
+    std::stringstream ptrstream_from;
+    ptrstream_from << from.get();
+    std::stringstream ptrstream_to;
+    ptrstream_to << to.get();
+
+    logger->template on<gko::log::Logger::polymorphic_object_move_started>(
+        exec.get(), from.get(), to.get());
+
+    auto os = out.str();
+    GKO_ASSERT_STR_CONTAINS(os, ptrstream_from.str());
+    GKO_ASSERT_STR_CONTAINS(os, "move started to");
+    GKO_ASSERT_STR_CONTAINS(os, ptrstream_to.str());
+}
+
+
+TYPED_TEST(Stream, CatchesPolymorphicObjectMoveCompleted)
+{
+    auto exec = gko::ReferenceExecutor::create();
+    std::stringstream out;
+    auto logger = gko::log::Stream<TypeParam>::create(
+        exec, gko::log::Logger::polymorphic_object_move_completed_mask, out);
+    auto from = gko::matrix::Dense<TypeParam>::create(exec);
+    auto to = gko::matrix::Dense<TypeParam>::create(exec);
+    std::stringstream ptrstream_from;
+    ptrstream_from << from.get();
+    std::stringstream ptrstream_to;
+    ptrstream_to << to.get();
+
+    logger->template on<gko::log::Logger::polymorphic_object_move_completed>(
+        exec.get(), from.get(), to.get());
+
+    auto os = out.str();
+    GKO_ASSERT_STR_CONTAINS(os, ptrstream_from.str());
+    GKO_ASSERT_STR_CONTAINS(os, "move completed to");
+    GKO_ASSERT_STR_CONTAINS(os, ptrstream_to.str());
+}
+
+
 TYPED_TEST(Stream, CatchesPolymorphicObjectDeleted)
 {
     auto exec = gko::ReferenceExecutor::create();