From 090205a18e76a1fa72c8cd989300850e927100cf Mon Sep 17 00:00:00 2001 From: Marcel Koch Date: Tue, 20 Sep 2022 17:42:10 +0200 Subject: [PATCH 01/10] fixes residual logging for distributed types --- core/distributed/helpers.hpp | 21 +++++++++++++++++++++ core/log/convergence.cpp | 16 +++++++++++----- core/log/papi.cpp | 16 ++++++++++------ 3 files changed, 42 insertions(+), 11 deletions(-) diff --git a/core/distributed/helpers.hpp b/core/distributed/helpers.hpp index 0e4f7b34e55..124404c8213 100644 --- a/core/distributed/helpers.hpp +++ b/core/distributed/helpers.hpp @@ -124,5 +124,26 @@ bool is_distributed(Arg* linop, Rest*... rest) } +template +void run_vector(T* linop, F&& f, Args... args) +{ +#if GINKGO_BUILD_MPI + if (is_distributed(linop)) { + using type = std::conditional_t< + std::is_const::value, + const experimental::distributed::Vector, + experimental::distributed::Vector>; + f(dynamic_cast(linop), std::forward(args)...); + } else +#endif + { + using type = std::conditional_t::value, + const matrix::Dense, + matrix::Dense>; + f(dynamic_cast(linop), std::forward(args)...); + } +} + + } // namespace detail } // namespace gko diff --git a/core/log/convergence.cpp b/core/log/convergence.cpp index 591df7cf758..2877df08046 100644 --- a/core/log/convergence.cpp +++ b/core/log/convergence.cpp @@ -35,10 +35,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include +#include #include #include +#include "core/base/dispatch_helper.hpp" +#include "core/distributed/helpers.hpp" + + namespace gko { namespace log { @@ -73,12 +78,13 @@ void Convergence::on_criterion_check_completed( if (residual_norm != nullptr) { this->residual_norm_.reset(residual_norm->clone().release()); } else if (residual != nullptr) { - using Vector = matrix::Dense; using NormVector = matrix::Dense>; - this->residual_norm_ = NormVector::create( - residual->get_executor(), dim<2>{1, residual->get_size()[1]}); - auto dense_r = as(residual); - dense_r->compute_norm2(this->residual_norm_.get()); + detail::run_vector(residual, [&](const auto* dense_r) { + this->residual_norm_ = + NormVector::create(residual->get_executor(), + dim<2>{1, residual->get_size()[1]}); + dense_r->compute_norm2(this->residual_norm_.get()); + }); } } } diff --git a/core/log/papi.cpp b/core/log/papi.cpp index cd9c8584027..31fc8f519ad 100644 --- a/core/log/papi.cpp +++ b/core/log/papi.cpp @@ -37,6 +37,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include +#include "core/distributed/helpers.hpp" + + namespace gko { namespace log { @@ -243,12 +246,13 @@ void Papi::on_criterion_check_completed( residual_norm_d = static_cast(std::real(dense_r_norm->at(0, 0))); } else if (residual != nullptr) { - auto tmp_res_norm = Vector::create(residual->get_executor(), - dim<2>{1, residual->get_size()[1]}); - auto dense_r = as(residual); - dense_r->compute_norm2(tmp_res_norm.get()); - residual_norm_d = - static_cast(std::real(tmp_res_norm->at(0, 0))); + detail::vector_dispatch(residual, [&](const auto* dense_r) { + auto tmp_res_norm = Vector::create( + residual->get_executor(), dim<2>{1, residual->get_size()[1]}); + dense_r->compute_norm2(tmp_res_norm.get()); + residual_norm_d = + static_cast(std::real(tmp_res_norm->at(0, 0))); + }); } const auto tmp = reinterpret_cast(criterion); From d7fe3cd58cb869991878877bee6f9e9c51e6bf0f Mon Sep 17 00:00:00 2001 From: Marcel Koch Date: Wed, 19 Oct 2022 15:05:37 +0200 Subject: [PATCH 02/10] adds tests for convergence logger --- core/test/log/convergence.cpp | 83 +++++++++++++++++++++++++++++++++-- 1 file changed, 79 insertions(+), 4 deletions(-) diff --git a/core/test/log/convergence.cpp b/core/test/log/convergence.cpp index 8e35ed413ed..7b813931801 100644 --- a/core/test/log/convergence.cpp +++ b/core/test/log/convergence.cpp @@ -44,17 +44,77 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. namespace { + template -class Convergence : public ::testing::Test {}; +class Convergence : public ::testing::Test { +public: + using Dense = gko::matrix::Dense; + + Convergence() + { + status.get_data()[0].reset(); + status.get_data()[0].converge(0); + } + + std::shared_ptr exec = + gko::ReferenceExecutor::create(); + + std::unique_ptr residual = gko::initialize({3, 4}, exec); + std::unique_ptr residual_norm = gko::initialize({5}, exec); + std::unique_ptr implicit_sq_resnorm = + gko::initialize({6}, exec); + std::unique_ptr solution = gko::initialize({-2, 7}, exec); + + gko::array status = {exec, 1}; +}; TYPED_TEST_SUITE(Convergence, gko::test::ValueTypes, TypenameNameGenerator); -TYPED_TEST(Convergence, CanGetData) +TYPED_TEST(Convergence, CanGetEmptyData) +{ + auto logger = gko::log::Convergence::create( + gko::log::Logger::criterion_events_mask); + + ASSERT_EQ(logger->has_converged(), false); + ASSERT_EQ(logger->get_num_iterations(), 0); + ASSERT_EQ(logger->get_residual(), nullptr); + ASSERT_EQ(logger->get_residual_norm(), nullptr); + ASSERT_EQ(logger->get_implicit_sq_resnorm(), nullptr); +} + + +TYPED_TEST(Convergence, CanLogData) { - auto exec = gko::ReferenceExecutor::create(); + using Dense = gko::matrix::Dense; auto logger = gko::log::Convergence::create( - gko::log::Logger::iteration_complete_mask); + gko::log::Logger::criterion_events_mask); + + logger->template on( + nullptr, 100, this->residual.get(), this->residual_norm.get(), + this->implicit_sq_resnorm.get(), this->solution.get(), 0, false, + &this->status, false, true); + + ASSERT_EQ(logger->has_converged(), true); + ASSERT_EQ(logger->get_num_iterations(), 100); + GKO_ASSERT_MTX_NEAR(gko::as(logger->get_residual()), + this->residual.get(), 0); + GKO_ASSERT_MTX_NEAR(gko::as(logger->get_residual_norm()), + this->residual_norm.get(), 0); + GKO_ASSERT_MTX_NEAR(gko::as(logger->get_implicit_sq_resnorm()), + this->implicit_sq_resnorm.get(), 0); +} + + +TYPED_TEST(Convergence, DoesNotLogIfNotStopped) +{ + auto logger = gko::log::Convergence::create( + gko::log::Logger::criterion_events_mask); + + logger->template on( + nullptr, 100, this->residual.get(), this->residual_norm.get(), + this->implicit_sq_resnorm.get(), this->solution.get(), 0, false, + &this->status, false, false); ASSERT_EQ(logger->has_converged(), false); ASSERT_EQ(logger->get_num_iterations(), 0); @@ -63,4 +123,19 @@ TYPED_TEST(Convergence, CanGetData) } +TYPED_TEST(Convergence, CanComputeResidualNorm) +{ + using Dense = gko::matrix::Dense; + auto logger = gko::log::Convergence::create( + gko::log::Logger::criterion_events_mask); + + logger->template on( + nullptr, 100, this->residual.get(), nullptr, nullptr, nullptr, 0, false, + &this->status, false, true); + + GKO_ASSERT_MTX_NEAR(gko::as(logger->get_residual_norm()), + this->residual_norm, r::value); +} + + } // namespace From dd414304078ebc97b52c049c35e2c62bf207ae27 Mon Sep 17 00:00:00 2001 From: Marcel Koch Date: Wed, 19 Oct 2022 15:55:35 +0200 Subject: [PATCH 03/10] small rename --- core/distributed/helpers.hpp | 2 +- core/log/convergence.cpp | 13 +++++++------ 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/core/distributed/helpers.hpp b/core/distributed/helpers.hpp index 124404c8213..f950d603157 100644 --- a/core/distributed/helpers.hpp +++ b/core/distributed/helpers.hpp @@ -125,7 +125,7 @@ bool is_distributed(Arg* linop, Rest*... rest) template -void run_vector(T* linop, F&& f, Args... args) +void vector_dispatch(T* linop, F&& f, Args... args) { #if GINKGO_BUILD_MPI if (is_distributed(linop)) { diff --git a/core/log/convergence.cpp b/core/log/convergence.cpp index 2877df08046..0f186a432a8 100644 --- a/core/log/convergence.cpp +++ b/core/log/convergence.cpp @@ -79,12 +79,13 @@ void Convergence::on_criterion_check_completed( this->residual_norm_.reset(residual_norm->clone().release()); } else if (residual != nullptr) { using NormVector = matrix::Dense>; - detail::run_vector(residual, [&](const auto* dense_r) { - this->residual_norm_ = - NormVector::create(residual->get_executor(), - dim<2>{1, residual->get_size()[1]}); - dense_r->compute_norm2(this->residual_norm_.get()); - }); + detail::vector_dispatch( + residual, [&](const auto* dense_r) { + this->residual_norm_ = + NormVector::create(residual->get_executor(), + dim<2>{1, residual->get_size()[1]}); + dense_r->compute_norm2(this->residual_norm_.get()); + }); } } } From eaffb7f0afa8b82869f71ece5637205ff9390390 Mon Sep 17 00:00:00 2001 From: Marcel Koch Date: Wed, 19 Oct 2022 15:55:46 +0200 Subject: [PATCH 04/10] adds test for vector dispatch --- core/test/mpi/distributed/CMakeLists.txt | 1 + core/test/mpi/distributed/helpers.cpp | 113 +++++++++++++++++++++++ 2 files changed, 114 insertions(+) create mode 100644 core/test/mpi/distributed/helpers.cpp diff --git a/core/test/mpi/distributed/CMakeLists.txt b/core/test/mpi/distributed/CMakeLists.txt index 2e35c68c4ac..49375072010 100644 --- a/core/test/mpi/distributed/CMakeLists.txt +++ b/core/test/mpi/distributed/CMakeLists.txt @@ -1 +1,2 @@ +ginkgo_create_test(helpers MPI_SIZE 1) ginkgo_create_test(matrix MPI_SIZE 1) diff --git a/core/test/mpi/distributed/helpers.cpp b/core/test/mpi/distributed/helpers.cpp new file mode 100644 index 00000000000..cc11e529462 --- /dev/null +++ b/core/test/mpi/distributed/helpers.cpp @@ -0,0 +1,113 @@ +/************************************************************* +Copyright (c) 2017-2022, the Ginkgo authors +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright +notice, this list of conditions and the following disclaimer in the +documentation and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*************************************************************/ + + +#include + + +#include "core/distributed/helpers.hpp" + + +#include "core/test/utils.hpp" + + +int run_function(gko::experimental::distributed::Vector<>*) { return 1; } + + +int run_function(const gko::experimental::distributed::Vector<>*) { return 2; } + + +int run_function(gko::matrix::Dense<>*) { return 3; } + + +int run_function(const gko::matrix::Dense<>*) { return 4; } + + +class RunVector : public ::testing::Test { +public: + std::shared_ptr exec = + gko::ReferenceExecutor::create(); +}; + + +TEST_F(RunVector, PicksDistributedVectorCorrectly) +{ + auto dist_vector = + gko::experimental::distributed::Vector<>::create(exec, MPI_COMM_WORLD); + int result; + + gko::detail::vector_dispatch( + dist_vector.get(), [&](auto* dense) { result = run_function(dense); }); + + ASSERT_EQ(result, run_function(dist_vector.get())); +} + + +TEST_F(RunVector, PicksConstDistributedVectorCorrectly) +{ + std::unique_ptr> + const_dist_vector = gko::experimental::distributed::Vector<>::create( + exec, MPI_COMM_WORLD); + int result; + + gko::detail::vector_dispatch( + const_dist_vector.get(), + [&](auto* dense) { result = run_function(dense); }); + + ASSERT_EQ(result, run_function(const_dist_vector.get())); +} + + +TEST_F(RunVector, PicksDenseVectorCorrectly) +{ + auto dense_vector = gko::matrix::Dense<>::create(exec); + int result; + + gko::detail::vector_dispatch( + dense_vector.get(), [&](auto* dense) { result = run_function(dense); }); + + ASSERT_EQ(result, run_function(dense_vector.get())); +} + + +TEST_F(RunVector, PicksConstDenseVectorCorrectly) +{ + std::unique_ptr> const_dense_vector = + gko::matrix::Dense<>::create(exec); + int result; + + gko::detail::vector_dispatch( + const_dense_vector.get(), + [&](auto* dense) { result = run_function(dense); }); + + ASSERT_EQ(result, run_function(const_dense_vector.get())); +} From 7de35b61ab17946a168484dd2da3631629f1eb5d Mon Sep 17 00:00:00 2001 From: Marcel Koch Date: Wed, 19 Oct 2022 16:00:52 +0200 Subject: [PATCH 05/10] adds documentation --- core/distributed/helpers.hpp | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/core/distributed/helpers.hpp b/core/distributed/helpers.hpp index f950d603157..4922daa1171 100644 --- a/core/distributed/helpers.hpp +++ b/core/distributed/helpers.hpp @@ -124,6 +124,21 @@ bool is_distributed(Arg* linop, Rest*... rest) } +/** + * Cast an input linop to the correct underlying vector type (dense/distributed) + * and passes it to the given function. + * + * @tparam ValueType The value type of the underlying dense or distributed + * vector. + * @tparam T The linop type, either LinOp, or const LinOp. + * @tparam F The function type. + * @tparam Args The types for the additional arguments of f. + * + * @param linop The linop to be casted into either a dense or distributed + * vector. + * @param f The function that is to be called with the correctly casted linop. + * @param args The additional arguments of f. + */ template void vector_dispatch(T* linop, F&& f, Args... args) { From 3e41f4f7e71c7e89ee979da911858fce2ffb2bef Mon Sep 17 00:00:00 2001 From: Marcel Koch Date: Mon, 24 Oct 2022 16:08:42 +0200 Subject: [PATCH 06/10] adds missing header guard --- core/distributed/helpers.hpp | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/core/distributed/helpers.hpp b/core/distributed/helpers.hpp index 4922daa1171..80cdcf625b1 100644 --- a/core/distributed/helpers.hpp +++ b/core/distributed/helpers.hpp @@ -30,6 +30,10 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************/ +#ifndef GKO_CORE_DISTRIBUTED_HELPERS_HPP_ +#define GKO_CORE_DISTRIBUTED_HELPERS_HPP_ + + #include @@ -162,3 +166,6 @@ void vector_dispatch(T* linop, F&& f, Args... args) } // namespace detail } // namespace gko + + +#endif From 41a7b4134c6170842812ec887c2bb225a86fbd30 Mon Sep 17 00:00:00 2001 From: Marcel Koch Date: Tue, 25 Oct 2022 09:59:22 +0200 Subject: [PATCH 07/10] uses correct absolute type for convergence test --- core/test/log/convergence.cpp | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/core/test/log/convergence.cpp b/core/test/log/convergence.cpp index 7b813931801..5e906fcd523 100644 --- a/core/test/log/convergence.cpp +++ b/core/test/log/convergence.cpp @@ -49,6 +49,7 @@ template class Convergence : public ::testing::Test { public: using Dense = gko::matrix::Dense; + using AbsoluteDense = gko::matrix::Dense>; Convergence() { @@ -60,9 +61,10 @@ class Convergence : public ::testing::Test { gko::ReferenceExecutor::create(); std::unique_ptr residual = gko::initialize({3, 4}, exec); - std::unique_ptr residual_norm = gko::initialize({5}, exec); - std::unique_ptr implicit_sq_resnorm = - gko::initialize({6}, exec); + std::unique_ptr residual_norm = + gko::initialize({5}, exec); + std::unique_ptr implicit_sq_resnorm = + gko::initialize({6}, exec); std::unique_ptr solution = gko::initialize({-2, 7}, exec); gko::array status = {exec, 1}; @@ -87,6 +89,7 @@ TYPED_TEST(Convergence, CanGetEmptyData) TYPED_TEST(Convergence, CanLogData) { using Dense = gko::matrix::Dense; + using AbsoluteDense = gko::matrix::Dense>; auto logger = gko::log::Convergence::create( gko::log::Logger::criterion_events_mask); @@ -99,10 +102,11 @@ TYPED_TEST(Convergence, CanLogData) ASSERT_EQ(logger->get_num_iterations(), 100); GKO_ASSERT_MTX_NEAR(gko::as(logger->get_residual()), this->residual.get(), 0); - GKO_ASSERT_MTX_NEAR(gko::as(logger->get_residual_norm()), + GKO_ASSERT_MTX_NEAR(gko::as(logger->get_residual_norm()), this->residual_norm.get(), 0); - GKO_ASSERT_MTX_NEAR(gko::as(logger->get_implicit_sq_resnorm()), - this->implicit_sq_resnorm.get(), 0); + GKO_ASSERT_MTX_NEAR( + gko::as(logger->get_implicit_sq_resnorm()), + this->implicit_sq_resnorm.get(), 0); } @@ -125,7 +129,7 @@ TYPED_TEST(Convergence, DoesNotLogIfNotStopped) TYPED_TEST(Convergence, CanComputeResidualNorm) { - using Dense = gko::matrix::Dense; + using AbsoluteDense = gko::matrix::Dense>; auto logger = gko::log::Convergence::create( gko::log::Logger::criterion_events_mask); @@ -133,7 +137,7 @@ TYPED_TEST(Convergence, CanComputeResidualNorm) nullptr, 100, this->residual.get(), nullptr, nullptr, nullptr, 0, false, &this->status, false, true); - GKO_ASSERT_MTX_NEAR(gko::as(logger->get_residual_norm()), + GKO_ASSERT_MTX_NEAR(gko::as(logger->get_residual_norm()), this->residual_norm, r::value); } From 22523f69a0d35ce853820fab5168ac5763259ab8 Mon Sep 17 00:00:00 2001 From: Marcel Koch Date: Wed, 26 Oct 2022 16:53:57 +0200 Subject: [PATCH 08/10] review updates: - formatting - fixes tests - test for nullptr/wrong type Co-authored-by: Yuhsiang M. Tsai Co-authored-by: Terry Cojean --- core/distributed/helpers.hpp | 8 +++-- core/test/mpi/distributed/helpers.cpp | 50 ++++++++++++++++++++------- 2 files changed, 43 insertions(+), 15 deletions(-) diff --git a/core/distributed/helpers.hpp b/core/distributed/helpers.hpp index 80cdcf625b1..526edb406ca 100644 --- a/core/distributed/helpers.hpp +++ b/core/distributed/helpers.hpp @@ -159,7 +159,11 @@ void vector_dispatch(T* linop, F&& f, Args... args) using type = std::conditional_t::value, const matrix::Dense, matrix::Dense>; - f(dynamic_cast(linop), std::forward(args)...); + if (auto concrete_linop = dynamic_cast(linop)) { + f(concrete_linop, std::forward(args)...); + } else { + GKO_NOT_SUPPORTED(linop); + } } } @@ -168,4 +172,4 @@ void vector_dispatch(T* linop, F&& f, Args... args) } // namespace gko -#endif +#endif // GKO_CORE_DISTRIBUTED_HELPERS_HPP_ diff --git a/core/test/mpi/distributed/helpers.cpp b/core/test/mpi/distributed/helpers.cpp index cc11e529462..4f05a4d703a 100644 --- a/core/test/mpi/distributed/helpers.cpp +++ b/core/test/mpi/distributed/helpers.cpp @@ -37,18 +37,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "core/distributed/helpers.hpp" +#include + + #include "core/test/utils.hpp" int run_function(gko::experimental::distributed::Vector<>*) { return 1; } - int run_function(const gko::experimental::distributed::Vector<>*) { return 2; } - int run_function(gko::matrix::Dense<>*) { return 3; } - int run_function(const gko::matrix::Dense<>*) { return 4; } @@ -61,47 +61,53 @@ class RunVector : public ::testing::Test { TEST_F(RunVector, PicksDistributedVectorCorrectly) { - auto dist_vector = + std::unique_ptr dist_vector = gko::experimental::distributed::Vector<>::create(exec, MPI_COMM_WORLD); int result; gko::detail::vector_dispatch( dist_vector.get(), [&](auto* dense) { result = run_function(dense); }); - ASSERT_EQ(result, run_function(dist_vector.get())); + ASSERT_EQ(result, + run_function(gko::as>( + dist_vector.get()))); } TEST_F(RunVector, PicksConstDistributedVectorCorrectly) { - std::unique_ptr> - const_dist_vector = gko::experimental::distributed::Vector<>::create( - exec, MPI_COMM_WORLD); + std::unique_ptr const_dist_vector = + gko::experimental::distributed::Vector<>::create(exec, MPI_COMM_WORLD); int result; gko::detail::vector_dispatch( const_dist_vector.get(), [&](auto* dense) { result = run_function(dense); }); - ASSERT_EQ(result, run_function(const_dist_vector.get())); + ASSERT_EQ( + result, + run_function(gko::as>( + const_dist_vector.get()))); } TEST_F(RunVector, PicksDenseVectorCorrectly) { - auto dense_vector = gko::matrix::Dense<>::create(exec); + std::unique_ptr dense_vector = + gko::matrix::Dense<>::create(exec); int result; gko::detail::vector_dispatch( dense_vector.get(), [&](auto* dense) { result = run_function(dense); }); - ASSERT_EQ(result, run_function(dense_vector.get())); + ASSERT_EQ(result, + run_function(gko::as>(dense_vector.get()))); } TEST_F(RunVector, PicksConstDenseVectorCorrectly) { - std::unique_ptr> const_dense_vector = + std::unique_ptr const_dense_vector = gko::matrix::Dense<>::create(exec); int result; @@ -109,5 +115,23 @@ TEST_F(RunVector, PicksConstDenseVectorCorrectly) const_dense_vector.get(), [&](auto* dense) { result = run_function(dense); }); - ASSERT_EQ(result, run_function(const_dense_vector.get())); + ASSERT_EQ(result, run_function(gko::as>( + const_dense_vector.get()))); +} + +TEST_F(RunVector, ThrowsIfWrongType) +{ + std::unique_ptr csr = gko::matrix::Csr<>::create(exec); + + ASSERT_THROW( + gko::detail::vector_dispatch(csr.get(), [&](auto* dense) {}), + gko::NotSupported); +} + + +TEST_F(RunVector, ThrowsIfNullptr) +{ + ASSERT_THROW(gko::detail::vector_dispatch( + static_cast(nullptr), [&](auto* dense) {}), + gko::NotSupported); } From 1f22585c20fe5bc6a5760e866502c926a9808557 Mon Sep 17 00:00:00 2001 From: ginkgo-bot Date: Wed, 2 Nov 2022 11:13:03 +0000 Subject: [PATCH 09/10] Format files Co-authored-by: Marcel Koch --- core/test/mpi/distributed/helpers.cpp | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/core/test/mpi/distributed/helpers.cpp b/core/test/mpi/distributed/helpers.cpp index 4f05a4d703a..b311cea437e 100644 --- a/core/test/mpi/distributed/helpers.cpp +++ b/core/test/mpi/distributed/helpers.cpp @@ -30,16 +30,13 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************/ - #include -#include "core/distributed/helpers.hpp" - - #include +#include "core/distributed/helpers.hpp" #include "core/test/utils.hpp" From 64f745891180640a25382ee82a61960252a14cd2 Mon Sep 17 00:00:00 2001 From: Marcel Koch Date: Wed, 2 Nov 2022 13:28:53 +0100 Subject: [PATCH 10/10] forwards args correctly in dispatch --- core/distributed/helpers.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/distributed/helpers.hpp b/core/distributed/helpers.hpp index 526edb406ca..ef689ffced8 100644 --- a/core/distributed/helpers.hpp +++ b/core/distributed/helpers.hpp @@ -144,7 +144,7 @@ bool is_distributed(Arg* linop, Rest*... rest) * @param args The additional arguments of f. */ template -void vector_dispatch(T* linop, F&& f, Args... args) +void vector_dispatch(T* linop, F&& f, Args&&... args) { #if GINKGO_BUILD_MPI if (is_distributed(linop)) {