From 797e80d7a775d3930f43a927a894447274dac94c Mon Sep 17 00:00:00 2001
From: "Yu-Hsiang M. Tsai" <yhmtsai@gmail.com>
Date: Tue, 28 Nov 2023 01:04:12 +0100
Subject: [PATCH] use deferred factory and update format

---
 core/config/solver_config.cpp             | 385 +++-------------------
 core/config/solver_config.hpp             |  48 +--
 core/solver/bicg.cpp                      |  12 +
 core/solver/bicgstab.cpp                  |  13 +
 core/solver/cb_gmres.cpp                  |  35 ++
 core/solver/cg.cpp                        |  31 +-
 core/solver/cgs.cpp                       |  12 +
 core/solver/direct.cpp                    |  17 +
 core/solver/fcg.cpp                       |  12 +
 core/solver/gcr.cpp                       |  13 +
 core/solver/gmres.cpp                     |  14 +
 core/solver/idr.cpp                       |  16 +
 core/solver/ir.cpp                        |  20 ++
 core/solver/lower_trs.cpp                 |  26 ++
 core/solver/upper_trs.cpp                 |  26 ++
 core/test/config/solver.cpp               | 179 +++++-----
 include/ginkgo/core/solver/bicg.hpp       |   6 +
 include/ginkgo/core/solver/bicgstab.hpp   |   6 +
 include/ginkgo/core/solver/cb_gmres.hpp   |   6 +
 include/ginkgo/core/solver/cgs.hpp        |   6 +
 include/ginkgo/core/solver/direct.hpp     |   6 +
 include/ginkgo/core/solver/fcg.hpp        |   6 +
 include/ginkgo/core/solver/gcr.hpp        |   6 +
 include/ginkgo/core/solver/gmres.hpp      |   6 +
 include/ginkgo/core/solver/idr.hpp        |   6 +
 include/ginkgo/core/solver/ir.hpp         |   6 +
 include/ginkgo/core/solver/triangular.hpp |  10 +
 27 files changed, 433 insertions(+), 496 deletions(-)

diff --git a/core/config/solver_config.cpp b/core/config/solver_config.cpp
index b0a451ebb4a..86c7efc0933 100644
--- a/core/config/solver_config.cpp
+++ b/core/config/solver_config.cpp
@@ -1,34 +1,6 @@
-/*******************************<GINKGO LICENSE>******************************
-Copyright (c) 2017-2023, 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.
-******************************<GINKGO LICENSE>*******************************/
+// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
 
 #include <ginkgo/core/base/exception_helpers.hpp>
 #include <ginkgo/core/config/config.hpp>
@@ -55,338 +27,65 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace gko {
 namespace config {
 
-
-// It can also be directly in solver (or in proteced part) if we also allow
-// the executor as input there.
-template <template <class> class Solver>
-class solver_helper {
-public:
-    template <typename ValueType>
-    class configurator {
-    public:
-        static std::unique_ptr<typename Solver<ValueType>::Factory>
-        build_from_config(const pnode& config, const registry& context,
-                          std::shared_ptr<const Executor> exec,
-                          type_descriptor td_for_child)
-        {
-            auto factory = Solver<ValueType>::build();
-            common_solver_configure(factory, config, context, exec,
-                                    td_for_child);
-            return factory.on(exec);
-        }
-    };
-};
-
-
-template <>
-std::unique_ptr<gko::LinOpFactory> build_from_config<LinOpFactoryType::Cg>(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor>& exec, gko::config::type_descriptor td)
-{
-    auto updated = update_type(config, td);
-    return dispatch<gko::LinOpFactory, solver_helper<solver::Cg>::configurator>(
-        updated.first, config, context, exec, updated, value_type_list());
-}
-
-template <>
-std::unique_ptr<gko::LinOpFactory> build_from_config<LinOpFactoryType::Bicg>(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor>& exec, gko::config::type_descriptor td)
-{
-    auto updated = update_type(config, td);
-    return dispatch<gko::LinOpFactory,
-                    solver_helper<solver::Bicg>::configurator>(
-        updated.first, config, context, exec, updated, value_type_list());
-}
-
-template <>
-std::unique_ptr<gko::LinOpFactory>
-build_from_config<LinOpFactoryType::Bicgstab>(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor>& exec, gko::config::type_descriptor td)
-{
-    auto updated = update_type(config, td);
-    return dispatch<gko::LinOpFactory,
-                    solver_helper<solver::Bicgstab>::configurator>(
-        updated.first, config, context, exec, updated, value_type_list());
-}
-
-template <>
-std::unique_ptr<gko::LinOpFactory> build_from_config<LinOpFactoryType::Cgs>(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor>& exec, gko::config::type_descriptor td)
-{
-    auto updated = update_type(config, td);
-    return dispatch<gko::LinOpFactory,
-                    solver_helper<solver::Cgs>::configurator>(
-        updated.first, config, context, exec, updated, value_type_list());
-}
-
-template <>
-std::unique_ptr<gko::LinOpFactory> build_from_config<LinOpFactoryType::Fcg>(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor>& exec, gko::config::type_descriptor td)
-{
-    auto updated = update_type(config, td);
-    return dispatch<gko::LinOpFactory,
-                    solver_helper<solver::Fcg>::configurator>(
-        updated.first, config, context, exec, updated, value_type_list());
-}
-
-
-template <typename ValueType>
-class IrConfigurator {
-public:
-    static std::unique_ptr<typename solver::Ir<ValueType>::Factory>
-    build_from_config(const pnode& config, const registry& context,
-                      std::shared_ptr<const Executor> exec,
-                      type_descriptor td_for_child)
-    {
-        auto factory = solver::Ir<ValueType>::build();
-        SET_POINTER_VECTOR(factory, const stop::CriterionFactory, criteria,
-                           config, context, exec, td_for_child);
-        SET_POINTER(factory, const LinOpFactory, solver, config, context, exec,
-                    td_for_child);
-
-        SET_POINTER(factory, const LinOp, generated_solver, config, context,
-                    exec, td_for_child);
-        SET_VALUE(factory, ValueType, relaxation_factor, config);
-        SET_VALUE(factory, solver::initial_guess_mode, default_initial_guess,
-                  config);
-        return factory.on(exec);
+// for valuetype only
+#define BUILD_FROM_CONFIG(_type)                                         \
+    template <>                                                          \
+    deferred_factory_parameter<gko::LinOpFactory>                        \
+    build_from_config<LinOpFactoryType::_type>(                          \
+        const pnode& config, const registry& context,                    \
+        gko::config::type_descriptor td)                                 \
+    {                                                                    \
+        auto updated = update_type(config, td);                          \
+        return dispatch<gko::LinOpFactory, gko::solver::_type>(          \
+            updated.first, config, context, updated, value_type_list()); \
     }
-};
-
 
-template <>
-std::unique_ptr<gko::LinOpFactory> build_from_config<LinOpFactoryType::Ir>(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor>& exec, gko::config::type_descriptor td)
-{
-    auto updated = update_type(config, td);
-    return dispatch<gko::LinOpFactory, IrConfigurator>(
-        updated.first, config, context, exec, updated, value_type_list());
-}
-
-
-template <typename ValueType>
-class IdrConfigurator {
-public:
-    static std::unique_ptr<typename solver::Idr<ValueType>::Factory>
-    build_from_config(const pnode& config, const registry& context,
-                      std::shared_ptr<const Executor> exec,
-                      type_descriptor td_for_child)
-    {
-        auto factory = solver::Idr<ValueType>::build();
-        common_solver_configure(factory, config, context, exec, td_for_child);
-        SET_VALUE(factory, size_type, subspace_dim, config);
-        SET_VALUE(factory, remove_complex<ValueType>, kappa, config);
-        SET_VALUE(factory, bool, deterministic, config);
-        SET_VALUE(factory, bool, complex_subspace, config);
-        return factory.on(exec);
-    }
-};
-
-
-template <>
-std::unique_ptr<gko::LinOpFactory> build_from_config<LinOpFactoryType::Idr>(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor>& exec, gko::config::type_descriptor td)
-{
-    auto updated = update_type(config, td);
-    return dispatch<gko::LinOpFactory, IdrConfigurator>(
-        updated.first, config, context, exec, updated, value_type_list());
-}
-
-
-template <typename ValueType>
-class GcrConfigurator {
-public:
-    static std::unique_ptr<typename solver::Gcr<ValueType>::Factory>
-    build_from_config(const pnode& config, const registry& context,
-                      std::shared_ptr<const Executor> exec,
-                      type_descriptor td_for_child)
-    {
-        auto factory = solver::Gcr<ValueType>::build();
-        common_solver_configure(factory, config, context, exec, td_for_child);
-        SET_VALUE(factory, size_type, krylov_dim, config);
-        return factory.on(exec);
-    }
-};
-
-
-template <>
-std::unique_ptr<gko::LinOpFactory> build_from_config<LinOpFactoryType::Gcr>(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor>& exec, gko::config::type_descriptor td)
-{
-    auto updated = update_type(config, td);
-    return dispatch<gko::LinOpFactory, GcrConfigurator>(
-        updated.first, config, context, exec, updated, value_type_list());
-}
-
-
-template <typename ValueType>
-class GmresConfigurator {
-public:
-    static std::unique_ptr<typename solver::Gmres<ValueType>::Factory>
-    build_from_config(const pnode& config, const registry& context,
-                      std::shared_ptr<const Executor> exec,
-                      type_descriptor td_for_child)
-    {
-        auto factory = solver::Gmres<ValueType>::build();
-        common_solver_configure(factory, config, context, exec, td_for_child);
-        SET_VALUE(factory, size_type, krylov_dim, config);
-        SET_VALUE(factory, bool, flexible, config);
-        return factory.on(exec);
-    }
-};
+BUILD_FROM_CONFIG(Cg)
+BUILD_FROM_CONFIG(Bicg)
+BUILD_FROM_CONFIG(Bicgstab)
+BUILD_FROM_CONFIG(Cgs)
+BUILD_FROM_CONFIG(Fcg)
+BUILD_FROM_CONFIG(Ir)
+BUILD_FROM_CONFIG(Idr)
+BUILD_FROM_CONFIG(Gcr)
+BUILD_FROM_CONFIG(Gmres)
+BUILD_FROM_CONFIG(CbGmres)
 
 
 template <>
-std::unique_ptr<gko::LinOpFactory> build_from_config<LinOpFactoryType::Gmres>(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor>& exec, gko::config::type_descriptor td)
+deferred_factory_parameter<gko::LinOpFactory>
+build_from_config<LinOpFactoryType::Direct>(const pnode& config,
+                                            const registry& context,
+                                            gko::config::type_descriptor td)
 {
     auto updated = update_type(config, td);
-    return dispatch<gko::LinOpFactory, GmresConfigurator>(
-        updated.first, config, context, exec, updated, value_type_list());
-}
-
-
-template <typename ValueType>
-class CbGmresConfigurator {
-public:
-    static std::unique_ptr<typename solver::CbGmres<ValueType>::Factory>
-    build_from_config(const pnode& config, const registry& context,
-                      std::shared_ptr<const Executor> exec,
-                      type_descriptor td_for_child)
-    {
-        auto factory = solver::CbGmres<ValueType>::build();
-        common_solver_configure(factory, config, context, exec, td_for_child);
-        SET_VALUE(factory, size_type, krylov_dim, config);
-        if (config.contains("storage_precision")) {
-            auto get_storage_precision = [](std::string str) {
-                using gko::solver::cb_gmres::storage_precision;
-                if (str == "keep") {
-                    return storage_precision::keep;
-                } else if (str == "reduce1") {
-                    return storage_precision::reduce1;
-                } else if (str == "reduce2") {
-                    return storage_precision::reduce2;
-                } else if (str == "integer") {
-                    return storage_precision::integer;
-                } else if (str == "ireduce1") {
-                    return storage_precision::ireduce1;
-                } else if (str == "ireduce2") {
-                    return storage_precision::ireduce2;
-                }
-                GKO_INVALID_STATE("Wrong value for storage_precision");
-            };
-            factory.with_storage_precision(get_storage_precision(
-                config.at("storage_precision").get_data<std::string>()));
-        }
-        return factory.on(exec);
-    }
-};
-
-
-template <>
-std::unique_ptr<gko::LinOpFactory> build_from_config<LinOpFactoryType::CbGmres>(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor>& exec, gko::config::type_descriptor td)
-{
-    auto updated = update_type(config, td);
-    return dispatch<gko::LinOpFactory, CbGmresConfigurator>(
-        updated.first, config, context, exec, updated, value_type_list());
-}
-
-
-template <typename ValueType, typename IndexType>
-class DirectConfigurator {
-public:
-    static std::unique_ptr<
-        typename experimental::solver::Direct<ValueType, IndexType>::Factory>
-    build_from_config(const pnode& config, const registry& context,
-                      std::shared_ptr<const Executor> exec,
-                      type_descriptor td_for_child)
-    {
-        auto factory =
-            experimental::solver::Direct<ValueType, IndexType>::build();
-        SET_VALUE(factory, size_type, num_rhs, config);
-        SET_POINTER(factory, const LinOpFactory, factorization, config, context,
-                    exec, td_for_child);
-        return factory.on(exec);
-    }
-};
-
-
-template <>
-std::unique_ptr<gko::LinOpFactory> build_from_config<LinOpFactoryType::Direct>(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor>& exec, gko::config::type_descriptor td)
-{
-    auto updated = update_type(config, td);
-    return dispatch<gko::LinOpFactory, DirectConfigurator>(
-        updated.first + "," + updated.second, config, context, exec, updated,
+    return dispatch<gko::LinOpFactory, gko::experimental::solver::Direct>(
+        updated.first + "," + updated.second, config, context, updated,
         value_type_list(), index_type_list());
 }
 
 
-template <template <class, class> class Trs>
-class trs_helper {
-public:
-    template <typename ValueType, typename IndexType>
-    class configurator {
-    public:
-        static std::unique_ptr<typename Trs<ValueType, IndexType>::Factory>
-        build_from_config(const pnode& config, const registry& context,
-                          std::shared_ptr<const Executor> exec,
-                          type_descriptor td_for_child)
-        {
-            auto factory = Trs<ValueType, IndexType>::build();
-            SET_VALUE(factory, size_type, num_rhs, config);
-            SET_VALUE(factory, bool, unit_diagonal, config);
-            if (config.contains("algorithm")) {
-                using gko::solver::trisolve_algorithm;
-                auto str = config.at("algorithm").get_data<std::string>();
-                if (str == "sparselib") {
-                    factory.with_algorithm(trisolve_algorithm::sparselib);
-                } else if (str == "syncfree") {
-                    factory.with_algorithm(trisolve_algorithm::syncfree);
-                } else {
-                    GKO_INVALID_STATE("Wrong value for algorithm");
-                }
-            }
-            return factory.on(exec);
-        }
-    };
-};
-
-
 template <>
-std::unique_ptr<gko::LinOpFactory>
-build_from_config<LinOpFactoryType::LowerTrs>(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor>& exec, gko::config::type_descriptor td)
+deferred_factory_parameter<gko::LinOpFactory>
+build_from_config<LinOpFactoryType::LowerTrs>(const pnode& config,
+                                              const registry& context,
+                                              gko::config::type_descriptor td)
 {
     auto updated = update_type(config, td);
-    return dispatch<gko::LinOpFactory,
-                    trs_helper<solver::LowerTrs>::configurator>(
-        updated.first + "," + updated.second, config, context, exec, updated,
+    return dispatch<gko::LinOpFactory, gko::solver::LowerTrs>(
+        updated.first + "," + updated.second, config, context, updated,
         value_type_list(), index_type_list());
 }
 
 template <>
-std::unique_ptr<gko::LinOpFactory>
-build_from_config<LinOpFactoryType::UpperTrs>(
-    const pnode& config, const registry& context,
-    std::shared_ptr<const Executor>& exec, gko::config::type_descriptor td)
+deferred_factory_parameter<gko::LinOpFactory>
+build_from_config<LinOpFactoryType::UpperTrs>(const pnode& config,
+                                              const registry& context,
+                                              gko::config::type_descriptor td)
 {
     auto updated = update_type(config, td);
-    return dispatch<gko::LinOpFactory,
-                    trs_helper<solver::UpperTrs>::configurator>(
-        updated.first + "," + updated.second, config, context, exec, updated,
+    return dispatch<gko::LinOpFactory, gko::solver::UpperTrs>(
+        updated.first + "," + updated.second, config, context, updated,
         value_type_list(), index_type_list());
 }
 
diff --git a/core/config/solver_config.hpp b/core/config/solver_config.hpp
index 49df4ff69fc..4dbfc0f1191 100644
--- a/core/config/solver_config.hpp
+++ b/core/config/solver_config.hpp
@@ -1,34 +1,6 @@
-/*******************************<GINKGO LICENSE>******************************
-Copyright (c) 2017-2023, 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.
-******************************<GINKGO LICENSE>*******************************/
+// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
 
 #ifndef GKO_CORE_CONFIG_SOLVER_CONFIG_HPP_
 #define GKO_CORE_CONFIG_SOLVER_CONFIG_HPP_
@@ -48,18 +20,14 @@ namespace config {
 template <typename SolverFactory>
 inline void common_solver_configure(SolverFactory& factory, const pnode& config,
                                     const registry& context,
-                                    std::shared_ptr<const Executor> exec,
                                     type_descriptor td_for_child)
 {
     SET_POINTER(factory, const LinOp, generated_preconditioner, config, context,
-                exec, td_for_child);
-    // handle parameter requires exec
-    // criteria and preconditioner are almost in each solver -> to another
-    // function.
-    SET_POINTER_VECTOR(factory, const stop::CriterionFactory, criteria, config,
-                       context, exec, td_for_child);
-    SET_POINTER(factory, const LinOpFactory, preconditioner, config, context,
-                exec, td_for_child);
+                td_for_child);
+    SET_FACTORY_VECTOR(factory, const stop::CriterionFactory, criteria, config,
+                       context, td_for_child);
+    SET_FACTORY(factory, const LinOpFactory, preconditioner, config, context,
+                td_for_child);
 }
 
 
diff --git a/core/solver/bicg.cpp b/core/solver/bicg.cpp
index 4ebcf706e12..de89c7e77f2 100644
--- a/core/solver/bicg.cpp
+++ b/core/solver/bicg.cpp
@@ -13,6 +13,7 @@
 #include <ginkgo/core/base/precision_dispatch.hpp>
 
 
+#include "core/config/solver_config.hpp"
 #include "core/solver/bicg_kernels.hpp"
 #include "core/solver/solver_boilerplate.hpp"
 
@@ -32,6 +33,17 @@ GKO_REGISTER_OPERATION(step_2, bicg::step_2);
 }  // namespace bicg
 
 
+template <typename ValueType>
+typename Bicg<ValueType>::parameters_type Bicg<ValueType>::build_from_config(
+    const config::pnode& config, const config::registry& context,
+    config::type_descriptor td_for_child)
+{
+    auto factory = solver::Bicg<ValueType>::build();
+    common_solver_configure(factory, config, context, td_for_child);
+    return factory;
+}
+
+
 template <typename ValueType>
 std::unique_ptr<LinOp> Bicg<ValueType>::transpose() const
 {
diff --git a/core/solver/bicgstab.cpp b/core/solver/bicgstab.cpp
index 927d563558a..43c05a7c5a1 100644
--- a/core/solver/bicgstab.cpp
+++ b/core/solver/bicgstab.cpp
@@ -14,6 +14,7 @@
 #include <ginkgo/core/solver/solver_base.hpp>
 
 
+#include "core/config/solver_config.hpp"
 #include "core/distributed/helpers.hpp"
 #include "core/solver/bicgstab_kernels.hpp"
 #include "core/solver/solver_boilerplate.hpp"
@@ -36,6 +37,18 @@ GKO_REGISTER_OPERATION(finalize, bicgstab::finalize);
 }  // namespace bicgstab
 
 
+template <typename ValueType>
+typename Bicgstab<ValueType>::parameters_type
+Bicgstab<ValueType>::build_from_config(const config::pnode& config,
+                                       const config::registry& context,
+                                       config::type_descriptor td_for_child)
+{
+    auto factory = solver::Bicgstab<ValueType>::build();
+    common_solver_configure(factory, config, context, td_for_child);
+    return factory;
+}
+
+
 template <typename ValueType>
 std::unique_ptr<LinOp> Bicgstab<ValueType>::transpose() const
 {
diff --git a/core/solver/cb_gmres.cpp b/core/solver/cb_gmres.cpp
index 050edeff5fc..0b7eaa5cff6 100644
--- a/core/solver/cb_gmres.cpp
+++ b/core/solver/cb_gmres.cpp
@@ -20,6 +20,7 @@
 
 
 #include "core/base/extended_float.hpp"
+#include "core/config/solver_config.hpp"
 #include "core/solver/cb_gmres_accessor.hpp"
 #include "core/solver/cb_gmres_kernels.hpp"
 
@@ -158,6 +159,40 @@ struct helper<std::complex<T>> {
 };
 
 
+template <typename ValueType>
+typename CbGmres<ValueType>::parameters_type
+CbGmres<ValueType>::build_from_config(const config::pnode& config,
+                                      const config::registry& context,
+                                      config::type_descriptor td_for_child)
+{
+    auto factory = solver::CbGmres<ValueType>::build();
+    common_solver_configure(factory, config, context, td_for_child);
+    SET_VALUE(factory, size_type, krylov_dim, config);
+    if (config.contains("storage_precision")) {
+        auto get_storage_precision = [](std::string str) {
+            using gko::solver::cb_gmres::storage_precision;
+            if (str == "keep") {
+                return storage_precision::keep;
+            } else if (str == "reduce1") {
+                return storage_precision::reduce1;
+            } else if (str == "reduce2") {
+                return storage_precision::reduce2;
+            } else if (str == "integer") {
+                return storage_precision::integer;
+            } else if (str == "ireduce1") {
+                return storage_precision::ireduce1;
+            } else if (str == "ireduce2") {
+                return storage_precision::ireduce2;
+            }
+            GKO_INVALID_STATE("Wrong value for storage_precision");
+        };
+        factory.with_storage_precision(get_storage_precision(
+            config.at("storage_precision").get_data<std::string>()));
+    }
+    return factory;
+}
+
+
 template <typename ValueType>
 void CbGmres<ValueType>::apply_impl(const LinOp* b, LinOp* x) const
 {
diff --git a/core/solver/cg.cpp b/core/solver/cg.cpp
index 7466a49dd6a..1de1551a497 100644
--- a/core/solver/cg.cpp
+++ b/core/solver/cg.cpp
@@ -14,30 +14,13 @@
 #include <ginkgo/core/base/utils.hpp>
 
 
+#include "core/config/solver_config.hpp"
 #include "core/distributed/helpers.hpp"
 #include "core/solver/cg_kernels.hpp"
 #include "core/solver/solver_boilerplate.hpp"
 
 
 namespace gko {
-namespace config {
-
-
-template <>
-deferred_factory_parameter<gko::LinOpFactory>
-build_from_config<static_cast<int>(LinOpFactoryType::Cg)>(
-    const pnode& config, const registry& context,
-    gko::config::type_descriptor td)
-{
-    auto updated = update_type(config, td);
-    return dispatch<gko::LinOpFactory, gko::solver::Cg>(
-        updated.first, config, context, updated, value_type_list());
-}
-
-
-}  // namespace config
-
-
 namespace solver {
 namespace cg {
 namespace {
@@ -58,17 +41,7 @@ typename Cg<ValueType>::parameters_type Cg<ValueType>::build_from_config(
     config::type_descriptor td_for_child)
 {
     auto factory = solver::Cg<ValueType>::build();
-    SET_POINTER(factory, const LinOp, generated_preconditioner, config, context,
-                td_for_child);
-    // handle parameter requires exec
-    // criteria and preconditioner are almost in each solver -> to another
-    // function.
-    SET_FACTORY_VECTOR(factory, const stop::CriterionFactory, criteria, config,
-                       context, td_for_child);
-    SET_FACTORY(factory, const LinOpFactory, preconditioner, config, context,
-                td_for_child);
-    // can also handle preconditioner, criterion here if they are in
-    // context.
+    common_solver_configure(factory, config, context, td_for_child);
     return factory;
 }
 
diff --git a/core/solver/cgs.cpp b/core/solver/cgs.cpp
index 06bb07704c7..43d9ecd4e80 100644
--- a/core/solver/cgs.cpp
+++ b/core/solver/cgs.cpp
@@ -14,6 +14,7 @@
 #include <ginkgo/core/solver/solver_base.hpp>
 
 
+#include "core/config/solver_config.hpp"
 #include "core/distributed/helpers.hpp"
 #include "core/solver/cgs_kernels.hpp"
 #include "core/solver/solver_boilerplate.hpp"
@@ -35,6 +36,17 @@ GKO_REGISTER_OPERATION(step_3, cgs::step_3);
 }  // namespace cgs
 
 
+template <typename ValueType>
+typename Cgs<ValueType>::parameters_type Cgs<ValueType>::build_from_config(
+    const config::pnode& config, const config::registry& context,
+    config::type_descriptor td_for_child)
+{
+    auto factory = solver::Cgs<ValueType>::build();
+    common_solver_configure(factory, config, context, td_for_child);
+    return factory;
+}
+
+
 template <typename ValueType>
 std::unique_ptr<LinOp> Cgs<ValueType>::transpose() const
 {
diff --git a/core/solver/direct.cpp b/core/solver/direct.cpp
index 880c0ecd00a..762510eb156 100644
--- a/core/solver/direct.cpp
+++ b/core/solver/direct.cpp
@@ -13,11 +13,28 @@
 #include <ginkgo/core/solver/solver_base.hpp>
 
 
+#include "core/config/config.hpp"
+
+
 namespace gko {
 namespace experimental {
 namespace solver {
 
 
+template <typename ValueType, typename IndexType>
+typename Direct<ValueType, IndexType>::parameters_type
+Direct<ValueType, IndexType>::build_from_config(
+    const config::pnode& config, const config::registry& context,
+    config::type_descriptor td_for_child)
+{
+    auto factory = Direct<ValueType, IndexType>::build();
+    SET_VALUE(factory, size_type, num_rhs, config);
+    SET_FACTORY(factory, const LinOpFactory, factorization, config, context,
+                td_for_child);
+    return factory;
+}
+
+
 template <typename ValueType, typename IndexType>
 std::unique_ptr<LinOp> Direct<ValueType, IndexType>::transpose() const
     GKO_NOT_IMPLEMENTED;
diff --git a/core/solver/fcg.cpp b/core/solver/fcg.cpp
index 7f3be1f734f..fe7c60de40b 100644
--- a/core/solver/fcg.cpp
+++ b/core/solver/fcg.cpp
@@ -13,6 +13,7 @@
 #include <ginkgo/core/base/utils.hpp>
 
 
+#include "core/config/solver_config.hpp"
 #include "core/distributed/helpers.hpp"
 #include "core/solver/fcg_kernels.hpp"
 #include "core/solver/solver_boilerplate.hpp"
@@ -33,6 +34,17 @@ GKO_REGISTER_OPERATION(step_2, fcg::step_2);
 }  // namespace fcg
 
 
+template <typename ValueType>
+typename Fcg<ValueType>::parameters_type Fcg<ValueType>::build_from_config(
+    const config::pnode& config, const config::registry& context,
+    config::type_descriptor td_for_child)
+{
+    auto factory = solver::Fcg<ValueType>::build();
+    common_solver_configure(factory, config, context, td_for_child);
+    return factory;
+}
+
+
 template <typename ValueType>
 std::unique_ptr<LinOp> Fcg<ValueType>::transpose() const
 {
diff --git a/core/solver/gcr.cpp b/core/solver/gcr.cpp
index 37fb632c7a8..9cfd562c686 100644
--- a/core/solver/gcr.cpp
+++ b/core/solver/gcr.cpp
@@ -16,6 +16,7 @@
 #include <ginkgo/core/matrix/identity.hpp>
 
 
+#include "core/config/solver_config.hpp"
 #include "core/distributed/helpers.hpp"
 #include "core/solver/gcr_kernels.hpp"
 #include "core/solver/solver_boilerplate.hpp"
@@ -36,6 +37,18 @@ GKO_REGISTER_OPERATION(step_1, gcr::step_1);
 }  // namespace gcr
 
 
+template <typename ValueType>
+typename Gcr<ValueType>::parameters_type Gcr<ValueType>::build_from_config(
+    const config::pnode& config, const config::registry& context,
+    config::type_descriptor td_for_child)
+{
+    auto factory = solver::Gcr<ValueType>::build();
+    common_solver_configure(factory, config, context, td_for_child);
+    SET_VALUE(factory, size_type, krylov_dim, config);
+    return factory;
+}
+
+
 template <typename ValueType>
 std::unique_ptr<LinOp> Gcr<ValueType>::transpose() const
 {
diff --git a/core/solver/gmres.cpp b/core/solver/gmres.cpp
index 7494f0bf4bb..07d6931e7d3 100644
--- a/core/solver/gmres.cpp
+++ b/core/solver/gmres.cpp
@@ -17,6 +17,7 @@
 #include <ginkgo/core/matrix/identity.hpp>
 
 
+#include "core/config/solver_config.hpp"
 #include "core/distributed/helpers.hpp"
 #include "core/solver/common_gmres_kernels.hpp"
 #include "core/solver/gmres_kernels.hpp"
@@ -40,6 +41,19 @@ GKO_REGISTER_OPERATION(multi_axpy, gmres::multi_axpy);
 }  // namespace gmres
 
 
+template <typename ValueType>
+typename Gmres<ValueType>::parameters_type Gmres<ValueType>::build_from_config(
+    const config::pnode& config, const config::registry& context,
+    config::type_descriptor td_for_child)
+{
+    auto factory = solver::Gmres<ValueType>::build();
+    common_solver_configure(factory, config, context, td_for_child);
+    SET_VALUE(factory, size_type, krylov_dim, config);
+    SET_VALUE(factory, bool, flexible, config);
+    return factory;
+}
+
+
 template <typename ValueType>
 std::unique_ptr<LinOp> Gmres<ValueType>::transpose() const
 {
diff --git a/core/solver/idr.cpp b/core/solver/idr.cpp
index 7b036ce6867..e919145f14d 100644
--- a/core/solver/idr.cpp
+++ b/core/solver/idr.cpp
@@ -13,6 +13,7 @@
 #include <ginkgo/core/solver/solver_base.hpp>
 
 
+#include "core/config/solver_config.hpp"
 #include "core/distributed/helpers.hpp"
 #include "core/solver/idr_kernels.hpp"
 #include "core/solver/solver_boilerplate.hpp"
@@ -35,6 +36,21 @@ GKO_REGISTER_OPERATION(compute_omega, idr::compute_omega);
 }  // namespace idr
 
 
+template <typename ValueType>
+typename Idr<ValueType>::parameters_type Idr<ValueType>::build_from_config(
+    const config::pnode& config, const config::registry& context,
+    config::type_descriptor td_for_child)
+{
+    auto factory = solver::Idr<ValueType>::build();
+    common_solver_configure(factory, config, context, td_for_child);
+    SET_VALUE(factory, size_type, subspace_dim, config);
+    SET_VALUE(factory, remove_complex<ValueType>, kappa, config);
+    SET_VALUE(factory, bool, deterministic, config);
+    SET_VALUE(factory, bool, complex_subspace, config);
+    return factory;
+}
+
+
 template <typename ValueType>
 std::unique_ptr<LinOp> Idr<ValueType>::transpose() const
 {
diff --git a/core/solver/ir.cpp b/core/solver/ir.cpp
index 3500d597684..1852e1d9381 100644
--- a/core/solver/ir.cpp
+++ b/core/solver/ir.cpp
@@ -10,6 +10,7 @@
 #include <ginkgo/core/solver/solver_base.hpp>
 
 
+#include "core/config/config.hpp"
 #include "core/distributed/helpers.hpp"
 #include "core/solver/ir_kernels.hpp"
 #include "core/solver/solver_base.hpp"
@@ -29,6 +30,25 @@ GKO_REGISTER_OPERATION(initialize, ir::initialize);
 }  // namespace ir
 
 
+template <typename ValueType>
+typename Ir<ValueType>::parameters_type Ir<ValueType>::build_from_config(
+    const config::pnode& config, const config::registry& context,
+    config::type_descriptor td_for_child)
+{
+    auto factory = solver::Ir<ValueType>::build();
+    SET_FACTORY_VECTOR(factory, const stop::CriterionFactory, criteria, config,
+                       context, td_for_child);
+    SET_FACTORY(factory, const LinOpFactory, solver, config, context,
+                td_for_child);
+    SET_POINTER(factory, const LinOp, generated_solver, config, context,
+                td_for_child);
+    SET_VALUE(factory, ValueType, relaxation_factor, config);
+    SET_VALUE(factory, solver::initial_guess_mode, default_initial_guess,
+              config);
+    return factory;
+}
+
+
 template <typename ValueType>
 void Ir<ValueType>::set_solver(std::shared_ptr<const LinOp> new_solver)
 {
diff --git a/core/solver/lower_trs.cpp b/core/solver/lower_trs.cpp
index e6fba4fdb20..8e48c62fd91 100644
--- a/core/solver/lower_trs.cpp
+++ b/core/solver/lower_trs.cpp
@@ -14,6 +14,7 @@
 #include <ginkgo/core/solver/triangular.hpp>
 
 
+#include "core/config/config.hpp"
 #include "core/solver/lower_trs_kernels.hpp"
 
 
@@ -33,6 +34,31 @@ GKO_REGISTER_OPERATION(solve, lower_trs::solve);
 }  // namespace lower_trs
 
 
+template <typename ValueType, typename IndexType>
+typename LowerTrs<ValueType, IndexType>::parameters_type
+LowerTrs<ValueType, IndexType>::build_from_config(
+    const config::pnode& config, const config::registry& context,
+    config::type_descriptor td_for_child)
+{
+    auto factory = LowerTrs<ValueType, IndexType>::build();
+    // duplicate?
+    SET_VALUE(factory, size_type, num_rhs, config);
+    SET_VALUE(factory, bool, unit_diagonal, config);
+    if (config.contains("algorithm")) {
+        using gko::solver::trisolve_algorithm;
+        auto str = config.at("algorithm").get_data<std::string>();
+        if (str == "sparselib") {
+            factory.with_algorithm(trisolve_algorithm::sparselib);
+        } else if (str == "syncfree") {
+            factory.with_algorithm(trisolve_algorithm::syncfree);
+        } else {
+            GKO_INVALID_STATE("Wrong value for algorithm");
+        }
+    }
+    return factory;
+}
+
+
 template <typename ValueType, typename IndexType>
 LowerTrs<ValueType, IndexType>::LowerTrs(const LowerTrs& other)
     : EnableLinOp<LowerTrs>(other.get_executor())
diff --git a/core/solver/upper_trs.cpp b/core/solver/upper_trs.cpp
index f2f49ec2c4a..f3e65dd196d 100644
--- a/core/solver/upper_trs.cpp
+++ b/core/solver/upper_trs.cpp
@@ -14,6 +14,7 @@
 #include <ginkgo/core/solver/triangular.hpp>
 
 
+#include "core/config/config.hpp"
 #include "core/solver/upper_trs_kernels.hpp"
 
 
@@ -33,6 +34,31 @@ GKO_REGISTER_OPERATION(solve, upper_trs::solve);
 }  // namespace upper_trs
 
 
+template <typename ValueType, typename IndexType>
+typename UpperTrs<ValueType, IndexType>::parameters_type
+UpperTrs<ValueType, IndexType>::build_from_config(
+    const config::pnode& config, const config::registry& context,
+    config::type_descriptor td_for_child)
+{
+    auto factory = UpperTrs<ValueType, IndexType>::build();
+    // duplicate?
+    SET_VALUE(factory, size_type, num_rhs, config);
+    SET_VALUE(factory, bool, unit_diagonal, config);
+    if (config.contains("algorithm")) {
+        using gko::solver::trisolve_algorithm;
+        auto str = config.at("algorithm").get_data<std::string>();
+        if (str == "sparselib") {
+            factory.with_algorithm(trisolve_algorithm::sparselib);
+        } else if (str == "syncfree") {
+            factory.with_algorithm(trisolve_algorithm::syncfree);
+        } else {
+            GKO_INVALID_STATE("Wrong value for algorithm");
+        }
+    }
+    return factory;
+}
+
+
 template <typename ValueType, typename IndexType>
 UpperTrs<ValueType, IndexType>::UpperTrs(const UpperTrs& other)
     : EnableLinOp<UpperTrs>(other.get_executor())
diff --git a/core/test/config/solver.cpp b/core/test/config/solver.cpp
index 6428ea2a681..29277ba7a80 100644
--- a/core/test/config/solver.cpp
+++ b/core/test/config/solver.cpp
@@ -1,34 +1,6 @@
-/*******************************<GINKGO LICENSE>******************************
-Copyright (c) 2017-2023, 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.
-******************************<GINKGO LICENSE>*******************************/
+// SPDX-FileCopyrightText: 2017-2023 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
 
 #include <typeinfo>
 
@@ -76,28 +48,28 @@ struct SolverConfigTest {
 
     static void change_template(pnode& config)
     {
-        config.get_list()["ValueType"] = pnode{"float"};
+        config.get_map()["ValueType"] = pnode{"float"};
     }
 
     template <bool from_reg, typename ParamType>
     static void set(pnode& config, ParamType& param, registry reg,
                     std::shared_ptr<const gko::Executor> exec)
     {
-        config.get_list()["generated_preconditioner"] = pnode{"linop"};
+        config.get_map()["generated_preconditioner"] = pnode{"linop"};
         param.with_generated_preconditioner(
             reg.search_data<gko::LinOp>("linop"));
         if (from_reg) {
-            config.get_list()["criteria"] = pnode{"criterion_factory"};
+            config.get_map()["criteria"] = pnode{"criterion_factory"};
             param.with_criteria(reg.search_data<gko::stop::CriterionFactory>(
                 "criterion_factory"));
-            config.get_list()["preconditioner"] = pnode{"linop_factory"};
+            config.get_map()["preconditioner"] = pnode{"linop_factory"};
             param.with_preconditioner(
                 reg.search_data<gko::LinOpFactory>("linop_factory"));
         } else {
-            config.get_list()["criteria"] =
-                pnode{{{"Type", pnode{"Iteration"}}}};
+            config.get_map()["criteria"] = pnode{
+                std::map<std::string, pnode>{{"Type", pnode{"Iteration"}}}};
             param.with_criteria(DummyStop::build().on(exec));
-            config.get_list()["preconditioner"] =
+            config.get_map()["preconditioner"] =
                 pnode{{{"Type", pnode{"Cg"}}, {"ValueType", pnode{"double"}}}};
             param.with_preconditioner(DummySolver::build().on(exec));
         }
@@ -129,59 +101,77 @@ struct SolverConfigTest {
 
 
 struct Cg : SolverConfigTest<gko::solver::Cg<float>, gko::solver::Cg<double>> {
-    static pnode setup_base() { return pnode{{{"Type", pnode{"Cg"}}}}; }
+    static pnode setup_base()
+    {
+        return pnode{std::map<std::string, pnode>{{"Type", pnode{"Cg"}}}};
+    }
 };
 
 
 struct Cgs
     : SolverConfigTest<gko::solver::Cgs<float>, gko::solver::Cgs<double>> {
-    static pnode setup_base() { return pnode{{{"Type", pnode{"Cgs"}}}}; }
+    static pnode setup_base()
+    {
+        return pnode{std::map<std::string, pnode>{{"Type", pnode{"Cgs"}}}};
+    }
 };
 
 
 struct Fcg
     : SolverConfigTest<gko::solver::Fcg<float>, gko::solver::Fcg<double>> {
-    static pnode setup_base() { return pnode{{{"Type", pnode{"Fcg"}}}}; }
+    static pnode setup_base()
+    {
+        return pnode{std::map<std::string, pnode>{{"Type", pnode{"Fcg"}}}};
+    }
 };
 
 
 struct Bicg
     : SolverConfigTest<gko::solver::Bicg<float>, gko::solver::Bicg<double>> {
-    static pnode setup_base() { return pnode{{{"Type", pnode{"Bicg"}}}}; }
+    static pnode setup_base()
+    {
+        return pnode{std::map<std::string, pnode>{{"Type", pnode{"Bicg"}}}};
+    }
 };
 
 
 struct Bicgstab : SolverConfigTest<gko::solver::Bicgstab<float>,
                                    gko::solver::Bicgstab<double>> {
-    static pnode setup_base() { return pnode{{{"Type", pnode{"Bicgstab"}}}}; }
+    static pnode setup_base()
+    {
+        return pnode{std::map<std::string, pnode>{{"Type", pnode{"Bicgstab"}}}};
+    }
 };
 
 
 struct Ir : SolverConfigTest<gko::solver::Ir<float>, gko::solver::Ir<double>> {
-    static pnode setup_base() { return pnode{{{"Type", pnode{"Ir"}}}}; }
+    static pnode setup_base()
+    {
+        return pnode{std::map<std::string, pnode>{{"Type", pnode{"Ir"}}}};
+    }
 
     template <bool from_reg, typename ParamType>
     static void set(pnode& config, ParamType& param, registry reg,
                     std::shared_ptr<const gko::Executor> exec)
     {
-        config.get_list()["generated_solver"] = pnode{"linop"};
+        config.get_map()["generated_solver"] = pnode{"linop"};
         param.with_generated_solver(reg.search_data<gko::LinOp>("linop"));
-        config.get_list()["relaxation_factor"] = pnode{1.2};
-        param.with_relaxation_factor(1.2);
-        config.get_list()["default_initial_guess"] = pnode{"zero"};
+        config.get_map()["relaxation_factor"] = pnode{1.2};
+        param.with_relaxation_factor(decltype(param.relaxation_factor){1.2});
+        config.get_map()["default_initial_guess"] = pnode{"zero"};
         param.with_default_initial_guess(gko::solver::initial_guess_mode::zero);
         if (from_reg) {
-            config.get_list()["criteria"] = pnode{"criterion_factory"};
+            config.get_map()["criteria"] = pnode{"criterion_factory"};
             param.with_criteria(reg.search_data<gko::stop::CriterionFactory>(
                 "criterion_factory"));
-            config.get_list()["solver"] = pnode{"linop_factory"};
+            config.get_map()["solver"] = pnode{"linop_factory"};
             param.with_solver(
                 reg.search_data<gko::LinOpFactory>("linop_factory"));
         } else {
-            config.get_list()["criteria"] =
-                pnode{{{"Type", pnode{"Iteration"}}}};
+            config.get_map()["criteria"] = pnode{
+                std::map<std::string, pnode>{{"Type", pnode{"Iteration"}}}};
             param.with_criteria(DummyStop::build().on(exec));
-            config.get_list()["solver"] =
+            config.get_map()["solver"] =
                 pnode{{{"Type", pnode{"Cg"}}, {"ValueType", pnode{"double"}}}};
             param.with_solver(DummySolver::build().on(exec));
         }
@@ -216,20 +206,23 @@ struct Ir : SolverConfigTest<gko::solver::Ir<float>, gko::solver::Ir<double>> {
 
 struct Idr
     : SolverConfigTest<gko::solver::Idr<float>, gko::solver::Idr<double>> {
-    static pnode setup_base() { return pnode{{{"Type", pnode{"Idr"}}}}; }
+    static pnode setup_base()
+    {
+        return pnode{std::map<std::string, pnode>{{"Type", pnode{"Idr"}}}};
+    }
 
     template <bool from_reg, typename ParamType>
     static void set(pnode& config, ParamType& param, registry reg,
                     std::shared_ptr<const gko::Executor> exec)
     {
         solver_config_test::template set<from_reg>(config, param, reg, exec);
-        config.get_list()["subspace_dim"] = pnode{3};
+        config.get_map()["subspace_dim"] = pnode{3};
         param.with_subspace_dim(3u);
-        config.get_list()["kappa"] = pnode{0.9};
-        param.with_kappa(0.9);
-        config.get_list()["deterministic"] = pnode{true};
+        config.get_map()["kappa"] = pnode{0.9};
+        param.with_kappa(decltype(param.kappa){0.9});
+        config.get_map()["deterministic"] = pnode{true};
         param.with_deterministic(true);
-        config.get_list()["complex_subspace"] = pnode{true};
+        config.get_map()["complex_subspace"] = pnode{true};
         param.with_complex_subspace(true);
     }
 
@@ -250,14 +243,17 @@ struct Idr
 
 struct Gcr
     : SolverConfigTest<gko::solver::Gcr<float>, gko::solver::Gcr<double>> {
-    static pnode setup_base() { return pnode{{{"Type", pnode{"Gcr"}}}}; }
+    static pnode setup_base()
+    {
+        return pnode{std::map<std::string, pnode>{{"Type", pnode{"Gcr"}}}};
+    }
 
     template <bool from_reg, typename ParamType>
     static void set(pnode& config, ParamType& param, registry reg,
                     std::shared_ptr<const gko::Executor> exec)
     {
         solver_config_test::template set<from_reg>(config, param, reg, exec);
-        config.get_list()["krylov_dim"] = pnode{3};
+        config.get_map()["krylov_dim"] = pnode{3};
         param.with_krylov_dim(3u);
     }
 
@@ -275,16 +271,19 @@ struct Gcr
 
 struct Gmres
     : SolverConfigTest<gko::solver::Gmres<float>, gko::solver::Gmres<double>> {
-    static pnode setup_base() { return pnode{{{"Type", pnode{"Gmres"}}}}; }
+    static pnode setup_base()
+    {
+        return pnode{std::map<std::string, pnode>{{"Type", pnode{"Gmres"}}}};
+    }
 
     template <bool from_reg, typename ParamType>
     static void set(pnode& config, ParamType& param, registry reg,
                     std::shared_ptr<const gko::Executor> exec)
     {
         solver_config_test::template set<from_reg>(config, param, reg, exec);
-        config.get_list()["krylov_dim"] = pnode{3};
+        config.get_map()["krylov_dim"] = pnode{3};
         param.with_krylov_dim(3u);
-        config.get_list()["flexible"] = pnode{true};
+        config.get_map()["flexible"] = pnode{true};
         param.with_flexible(true);
     }
 
@@ -303,16 +302,19 @@ struct Gmres
 
 struct CbGmres : SolverConfigTest<gko::solver::CbGmres<float>,
                                   gko::solver::CbGmres<double>> {
-    static pnode setup_base() { return pnode{{{"Type", pnode{"CbGmres"}}}}; }
+    static pnode setup_base()
+    {
+        return pnode{std::map<std::string, pnode>{{"Type", pnode{"CbGmres"}}}};
+    }
 
     template <bool from_reg, typename ParamType>
     static void set(pnode& config, ParamType& param, registry reg,
                     std::shared_ptr<const gko::Executor> exec)
     {
         solver_config_test::template set<from_reg>(config, param, reg, exec);
-        config.get_list()["krylov_dim"] = pnode{3};
+        config.get_map()["krylov_dim"] = pnode{3};
         param.with_krylov_dim(3u);
-        config.get_list()["storage_precision"] = pnode{"reduce2"};
+        config.get_map()["storage_precision"] = pnode{"reduce2"};
         param.with_storage_precision(
             gko::solver::cb_gmres::storage_precision::reduce2);
     }
@@ -333,26 +335,29 @@ struct CbGmres : SolverConfigTest<gko::solver::CbGmres<float>,
 struct Direct
     : SolverConfigTest<gko::experimental::solver::Direct<float, gko::int64>,
                        gko::experimental::solver::Direct<double, int>> {
-    static pnode setup_base() { return pnode{{{"Type", pnode{"Direct"}}}}; }
+    static pnode setup_base()
+    {
+        return pnode{std::map<std::string, pnode>{{"Type", pnode{"Direct"}}}};
+    }
 
     static void change_template(pnode& config)
     {
-        config.get_list()["ValueType"] = pnode{"float"};
-        config.get_list()["IndexType"] = pnode{"int64"};
+        config.get_map()["ValueType"] = pnode{"float"};
+        config.get_map()["IndexType"] = pnode{"int64"};
     }
 
     template <bool from_reg, typename ParamType>
     static void set(pnode& config, ParamType& param, registry reg,
                     std::shared_ptr<const gko::Executor> exec)
     {
-        config.get_list()["num_rhs"] = pnode{3};
+        config.get_map()["num_rhs"] = pnode{3};
         param.with_num_rhs(3u);
         if (from_reg) {
-            config.get_list()["factorization"] = pnode{"linop_factory"};
+            config.get_map()["factorization"] = pnode{"linop_factory"};
             param.with_factorization(
                 reg.search_data<gko::LinOpFactory>("linop_factory"));
         } else {
-            config.get_list()["factorization"] =
+            config.get_map()["factorization"] =
                 pnode{{{"Type", pnode{"Cg"}}, {"ValueType", pnode{"double"}}}};
             param.with_factorization(DummySolver::build().on(exec));
         }
@@ -381,19 +386,19 @@ template <template <class, class> class Trs>
 struct TrsHelper : SolverConfigTest<Trs<float, gko::int64>, Trs<double, int>> {
     static void change_template(pnode& config)
     {
-        config.get_list()["ValueType"] = pnode{"float"};
-        config.get_list()["IndexType"] = pnode{"int64"};
+        config.get_map()["ValueType"] = pnode{"float"};
+        config.get_map()["IndexType"] = pnode{"int64"};
     }
 
     template <bool from_reg, typename ParamType>
     static void set(pnode& config, ParamType& param, registry reg,
                     std::shared_ptr<const gko::Executor> exec)
     {
-        config.get_list()["num_rhs"] = pnode{3};
+        config.get_map()["num_rhs"] = pnode{3};
         param.with_num_rhs(3u);
-        config.get_list()["unit_diagonal"] = pnode{true};
+        config.get_map()["unit_diagonal"] = pnode{true};
         param.with_unit_diagonal(true);
-        config.get_list()["algorithm"] = pnode{"syncfree"};
+        config.get_map()["algorithm"] = pnode{"syncfree"};
         param.with_algorithm(gko::solver::trisolve_algorithm::syncfree);
     }
 
@@ -411,12 +416,18 @@ struct TrsHelper : SolverConfigTest<Trs<float, gko::int64>, Trs<double, int>> {
 
 
 struct LowerTrs : TrsHelper<gko::solver::LowerTrs> {
-    static pnode setup_base() { return pnode{{{"Type", pnode{"LowerTrs"}}}}; }
+    static pnode setup_base()
+    {
+        return pnode{std::map<std::string, pnode>{{"Type", pnode{"LowerTrs"}}}};
+    }
 };
 
 
 struct UpperTrs : TrsHelper<gko::solver::UpperTrs> {
-    static pnode setup_base() { return pnode{{{"Type", pnode{"UpperTrs"}}}}; }
+    static pnode setup_base()
+    {
+        return pnode{std::map<std::string, pnode>{{"Type", pnode{"UpperTrs"}}}};
+    }
 };
 
 
@@ -460,7 +471,7 @@ TYPED_TEST(Solver, CreateDefault)
     using Config = typename TestFixture::Config;
     auto config = Config::setup_base();
 
-    auto res = build_from_config(config, this->reg, this->exec, this->td);
+    auto res = build_from_config(config, this->reg, this->td).on(this->exec);
     auto ans = Config::default_type::build().on(this->exec);
 
     Config::template validate<true>(res.get(), ans.get());
@@ -473,7 +484,7 @@ TYPED_TEST(Solver, ExplicitTemplate)
     auto config = Config::setup_base();
     Config::change_template(config);
 
-    auto res = build_from_config(config, this->reg, this->exec, this->td);
+    auto res = build_from_config(config, this->reg, this->td).on(this->exec);
     auto ans = Config::solver_type::build().on(this->exec);
 
     Config::template validate<true>(res.get(), ans.get());
@@ -488,7 +499,7 @@ TYPED_TEST(Solver, SetFromRegistry)
     auto param = Config::solver_type::build();
     Config::template set<true>(config, param, this->reg, this->exec);
 
-    auto res = build_from_config(config, this->reg, this->exec, this->td);
+    auto res = build_from_config(config, this->reg, this->td).on(this->exec);
     auto ans = param.on(this->exec);
 
     Config::template validate<true>(res.get(), ans.get());
@@ -503,7 +514,7 @@ TYPED_TEST(Solver, SetFromConfig)
     auto param = Config::solver_type::build();
     Config::template set<false>(config, param, this->reg, this->exec);
 
-    auto res = build_from_config(config, this->reg, this->exec, this->td);
+    auto res = build_from_config(config, this->reg, this->td).on(this->exec);
     auto ans = param.on(this->exec);
 
     Config::template validate<false>(res.get(), ans.get());
diff --git a/include/ginkgo/core/solver/bicg.hpp b/include/ginkgo/core/solver/bicg.hpp
index b35928d140f..c7da1edcd65 100644
--- a/include/ginkgo/core/solver/bicg.hpp
+++ b/include/ginkgo/core/solver/bicg.hpp
@@ -14,6 +14,8 @@
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/math.hpp>
 #include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/log/logger.hpp>
 #include <ginkgo/core/matrix/csr.hpp>
 #include <ginkgo/core/matrix/dense.hpp>
@@ -80,6 +82,10 @@ class Bicg
     GKO_ENABLE_LIN_OP_FACTORY(Bicg, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
 
+    static parameters_type build_from_config(
+        const config::pnode& config, const config::registry& context,
+        config::type_descriptor td_for_child);
+
 protected:
     void apply_impl(const LinOp* b, LinOp* x) const override;
 
diff --git a/include/ginkgo/core/solver/bicgstab.hpp b/include/ginkgo/core/solver/bicgstab.hpp
index 36bf276ef8b..43a6c6b51d1 100644
--- a/include/ginkgo/core/solver/bicgstab.hpp
+++ b/include/ginkgo/core/solver/bicgstab.hpp
@@ -14,6 +14,8 @@
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/math.hpp>
 #include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/log/logger.hpp>
 #include <ginkgo/core/matrix/dense.hpp>
 #include <ginkgo/core/matrix/identity.hpp>
@@ -78,6 +80,10 @@ class Bicgstab
     GKO_ENABLE_LIN_OP_FACTORY(Bicgstab, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
 
+    static parameters_type build_from_config(
+        const config::pnode& config, const config::registry& context,
+        config::type_descriptor td_for_child);
+
 protected:
     void apply_impl(const LinOp* b, LinOp* x) const override;
 
diff --git a/include/ginkgo/core/solver/cb_gmres.hpp b/include/ginkgo/core/solver/cb_gmres.hpp
index 9aad86c2923..ad14e86543c 100644
--- a/include/ginkgo/core/solver/cb_gmres.hpp
+++ b/include/ginkgo/core/solver/cb_gmres.hpp
@@ -15,6 +15,8 @@
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/math.hpp>
 #include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/log/logger.hpp>
 #include <ginkgo/core/matrix/dense.hpp>
 #include <ginkgo/core/matrix/identity.hpp>
@@ -145,6 +147,10 @@ class CbGmres : public EnableLinOp<CbGmres<ValueType>>,
     GKO_ENABLE_LIN_OP_FACTORY(CbGmres, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
 
+    static parameters_type build_from_config(
+        const config::pnode& config, const config::registry& context,
+        config::type_descriptor td_for_child);
+
 protected:
     void apply_impl(const LinOp* b, LinOp* x) const override;
 
diff --git a/include/ginkgo/core/solver/cgs.hpp b/include/ginkgo/core/solver/cgs.hpp
index bf2429fe659..7d60baf5eeb 100644
--- a/include/ginkgo/core/solver/cgs.hpp
+++ b/include/ginkgo/core/solver/cgs.hpp
@@ -14,6 +14,8 @@
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/math.hpp>
 #include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/log/logger.hpp>
 #include <ginkgo/core/matrix/dense.hpp>
 #include <ginkgo/core/matrix/identity.hpp>
@@ -71,6 +73,10 @@ class Cgs
     GKO_ENABLE_LIN_OP_FACTORY(Cgs, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
 
+    static parameters_type build_from_config(
+        const config::pnode& config, const config::registry& context,
+        config::type_descriptor td_for_child);
+
 protected:
     void apply_impl(const LinOp* b, LinOp* x) const override;
 
diff --git a/include/ginkgo/core/solver/direct.hpp b/include/ginkgo/core/solver/direct.hpp
index e9dd9763b93..6d9c47c1486 100644
--- a/include/ginkgo/core/solver/direct.hpp
+++ b/include/ginkgo/core/solver/direct.hpp
@@ -7,6 +7,8 @@
 
 
 #include <ginkgo/core/base/lin_op.hpp>
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/factorization/factorization.hpp>
 #include <ginkgo/core/solver/solver_base.hpp>
 #include <ginkgo/core/solver/triangular.hpp>
@@ -65,6 +67,10 @@ class Direct : public EnableLinOp<Direct<ValueType, IndexType>>,
     GKO_ENABLE_LIN_OP_FACTORY(Direct, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
 
+    static parameters_type build_from_config(
+        const config::pnode& config, const config::registry& context,
+        config::type_descriptor td_for_child);
+
     /** Creates a copy of the solver. */
     Direct(const Direct&);
 
diff --git a/include/ginkgo/core/solver/fcg.hpp b/include/ginkgo/core/solver/fcg.hpp
index 7d73b51128d..9b5d7da82af 100644
--- a/include/ginkgo/core/solver/fcg.hpp
+++ b/include/ginkgo/core/solver/fcg.hpp
@@ -14,6 +14,8 @@
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/math.hpp>
 #include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/log/logger.hpp>
 #include <ginkgo/core/matrix/dense.hpp>
 #include <ginkgo/core/matrix/identity.hpp>
@@ -79,6 +81,10 @@ class Fcg
     GKO_ENABLE_LIN_OP_FACTORY(Fcg, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
 
+    static parameters_type build_from_config(
+        const config::pnode& config, const config::registry& context,
+        config::type_descriptor td_for_child);
+
 protected:
     void apply_impl(const LinOp* b, LinOp* x) const override;
 
diff --git a/include/ginkgo/core/solver/gcr.hpp b/include/ginkgo/core/solver/gcr.hpp
index b3ac3f47fd2..6ba6da0d249 100644
--- a/include/ginkgo/core/solver/gcr.hpp
+++ b/include/ginkgo/core/solver/gcr.hpp
@@ -14,6 +14,8 @@
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/math.hpp>
 #include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/log/logger.hpp>
 #include <ginkgo/core/matrix/dense.hpp>
 #include <ginkgo/core/matrix/identity.hpp>
@@ -91,6 +93,10 @@ class Gcr
     GKO_ENABLE_LIN_OP_FACTORY(Gcr, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
 
+    static parameters_type build_from_config(
+        const config::pnode& config, const config::registry& context,
+        config::type_descriptor td_for_child);
+
 protected:
     void apply_impl(const LinOp* b, LinOp* x) const override;
 
diff --git a/include/ginkgo/core/solver/gmres.hpp b/include/ginkgo/core/solver/gmres.hpp
index b6832e9d9c5..0ee73ea3fb9 100644
--- a/include/ginkgo/core/solver/gmres.hpp
+++ b/include/ginkgo/core/solver/gmres.hpp
@@ -14,6 +14,8 @@
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/math.hpp>
 #include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/log/logger.hpp>
 #include <ginkgo/core/matrix/dense.hpp>
 #include <ginkgo/core/matrix/identity.hpp>
@@ -96,6 +98,10 @@ class Gmres
     GKO_ENABLE_LIN_OP_FACTORY(Gmres, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
 
+    static parameters_type build_from_config(
+        const config::pnode& config, const config::registry& context,
+        config::type_descriptor td_for_child);
+
 protected:
     void apply_impl(const LinOp* b, LinOp* x) const override;
 
diff --git a/include/ginkgo/core/solver/idr.hpp b/include/ginkgo/core/solver/idr.hpp
index 38febef3e1a..26346609d20 100644
--- a/include/ginkgo/core/solver/idr.hpp
+++ b/include/ginkgo/core/solver/idr.hpp
@@ -16,6 +16,8 @@
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/math.hpp>
 #include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/log/logger.hpp>
 #include <ginkgo/core/matrix/dense.hpp>
 #include <ginkgo/core/matrix/identity.hpp>
@@ -194,6 +196,10 @@ class Idr
     GKO_ENABLE_LIN_OP_FACTORY(Idr, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
 
+    static parameters_type build_from_config(
+        const config::pnode& config, const config::registry& context,
+        config::type_descriptor td_for_child);
+
 protected:
     void apply_impl(const LinOp* b, LinOp* x) const override;
 
diff --git a/include/ginkgo/core/solver/ir.hpp b/include/ginkgo/core/solver/ir.hpp
index 3182aff3af8..f7b5c0d5a6c 100644
--- a/include/ginkgo/core/solver/ir.hpp
+++ b/include/ginkgo/core/solver/ir.hpp
@@ -12,6 +12,8 @@
 #include <ginkgo/core/base/exception_helpers.hpp>
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/matrix/dense.hpp>
 #include <ginkgo/core/matrix/identity.hpp>
 #include <ginkgo/core/solver/solver_base.hpp>
@@ -182,6 +184,10 @@ class Ir : public EnableLinOp<Ir<ValueType>>,
     GKO_ENABLE_LIN_OP_FACTORY(Ir, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
 
+    static parameters_type build_from_config(
+        const config::pnode& config, const config::registry& context,
+        config::type_descriptor td_for_child);
+
 protected:
     void apply_impl(const LinOp* b, LinOp* x) const override;
 
diff --git a/include/ginkgo/core/solver/triangular.hpp b/include/ginkgo/core/solver/triangular.hpp
index 5cb79850fa4..e32b1078618 100644
--- a/include/ginkgo/core/solver/triangular.hpp
+++ b/include/ginkgo/core/solver/triangular.hpp
@@ -18,6 +18,8 @@
 #include <ginkgo/core/base/polymorphic_object.hpp>
 #include <ginkgo/core/base/types.hpp>
 #include <ginkgo/core/base/utils.hpp>
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/log/logger.hpp>
 #include <ginkgo/core/matrix/csr.hpp>
 #include <ginkgo/core/matrix/identity.hpp>
@@ -106,6 +108,10 @@ class LowerTrs : public EnableLinOp<LowerTrs<ValueType, IndexType>>,
     GKO_ENABLE_LIN_OP_FACTORY(LowerTrs, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
 
+    static parameters_type build_from_config(
+        const config::pnode& config, const config::registry& context,
+        config::type_descriptor td_for_child);
+
     /**
      * Copy-assigns a triangular solver. Preserves the executor, shallow-copies
      * the system matrix. If the executors mismatch, clones system matrix onto
@@ -256,6 +262,10 @@ class UpperTrs : public EnableLinOp<UpperTrs<ValueType, IndexType>>,
     GKO_ENABLE_LIN_OP_FACTORY(UpperTrs, parameters, Factory);
     GKO_ENABLE_BUILD_METHOD(Factory);
 
+    static parameters_type build_from_config(
+        const config::pnode& config, const config::registry& context,
+        config::type_descriptor td_for_child);
+
     /**
      * Copy-assigns a triangular solver. Preserves the executor, shallow-copies
      * the system matrix. If the executors mismatch, clones system matrix onto