add min_iters to simple criterion

Author: yhmtsai

core/config/config_helper.cpp

@@ -9,6 +9,7 @@
 #include <ginkgo/core/base/exception_helpers.hpp>
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/config/registry.hpp>
+#include <ginkgo/core/stop/iteration.hpp>
 
 #include "core/config/registry_accessor.hpp"
 #include "core/config/stop_config.hpp"
@@ -118,21 +119,32 @@ parse_minimal_criteria(const pnode& config, const registry& context,
     // We use additional scope such that we check it before the following map
     // throw exception
     {
-        config_check_decorator config_check(config);
+        config_check_decorator config_check(config, {{"min_iters"}});
         for (const auto& it : criterion_map) {
             config_check.get(it.first);
         }
     }
 
+
     std::vector<deferred_factory_parameter<const stop::CriterionFactory>> res;
     for (const auto& it : config.get_map()) {
-        if (it.first == "value_type") {
+        if (it.first == "value_type" || it.first == "min_iters") {
             continue;
         }
         res.emplace_back(
             criterion_map.at(it.first)(config, context, updated_td));
     }
-    return res;
+    if (auto& obj = config.get("min_iters")) {
+        auto counts = get_value<size_type>(obj);
+        if (res.size() == 1) {
+            return {stop::min_iters(counts, res.at(0))};
+        } else {
+            return {stop::min_iters(
+                counts, stop::Combined::build().with_criteria(res))};
+        }
+    } else {
+        return res;
+    }
 }
 
 

core/stop/iteration.cpp

@@ -31,7 +31,8 @@ deferred_factory_parameter<Iteration::Factory> max_iters(size_type count)
 
 
 deferred_factory_parameter<CriterionFactory> min_iters(
-    size_type count, deferred_factory_parameter<CriterionFactory> criterion)
+    size_type count,
+    deferred_factory_parameter<const CriterionFactory> criterion)
 {
     return MinIterationWrapper::build()
         .with_min_iters(count)

core/test/config/config.cpp

@@ -16,6 +16,7 @@
 #include <ginkgo/core/stop/time.hpp>
 
 #include "core/config/config_helper.hpp"
+#include "core/stop/iteration.hpp"
 #include "core/test/utils.hpp"
 
 
@@ -286,6 +287,68 @@ TEST_F(Config, GenerateCriteriaFromMinimalConfigWithValueType)
 }
 
 
+TEST_F(Config, GenerateOneCriteriaFromMinimalConfigWithMinIters)
+{
+    auto reg = registry();
+    reg.emplace("precond", this->mtx);
+    pnode minimal_stop{{{"iteration", pnode{5}}, {"min_iters", pnode{10}}}};
+
+    pnode p{{{"criteria", minimal_stop}}};
+    auto obj = std::dynamic_pointer_cast<gko::solver::Cg<float>::Factory>(
+        parse<LinOpFactoryType::Cg>(p, reg, type_descriptor{"float32", "void"})
+            .on(this->exec));
+
+    ASSERT_NE(obj, nullptr);
+    auto criteria = gko::as<gko::stop::MinIterationWrapper::Factory>(
+        obj->get_parameters().criteria.at(0));
+    auto inner = gko::as<gko::stop::Iteration::Factory>(
+        criteria->get_parameters().inner_criterion);
+    ASSERT_EQ(criteria->get_parameters().min_iters, 10);
+    ASSERT_EQ(inner->get_parameters().max_iters, 5);
+}
+
+
+TEST_F(Config, GenerateCriteriaFromMinimalConfigWithMinIters)
+{
+    auto reg = registry();
+    reg.emplace("precond", this->mtx);
+    pnode minimal_stop{{{"iteration", pnode{5}},
+                        {"time", pnode{100}},
+                        {"min_iters", pnode{10}}}};
+
+    pnode p{{{"criteria", minimal_stop}}};
+    auto obj = std::dynamic_pointer_cast<gko::solver::Cg<float>::Factory>(
+        parse<LinOpFactoryType::Cg>(p, reg, type_descriptor{"float32", "void"})
+            .on(this->exec));
+
+    ASSERT_NE(obj, nullptr);
+    auto criteria = gko::as<gko::stop::MinIterationWrapper::Factory>(
+        obj->get_parameters().criteria.at(0));
+    auto inner = gko::as<gko::stop::Combined::Factory>(
+        criteria->get_parameters().inner_criterion);
+    ASSERT_EQ(criteria->get_parameters().min_iters, 10);
+    ASSERT_EQ(inner->get_parameters().criteria.size(), 2);
+    if (auto inner1 = gko::as<gko::stop::Iteration::Factory>(
+            inner->get_parameters().criteria.at(0))) {
+        auto inner2 = gko::as<gko::stop::Time::Factory>(
+            inner->get_parameters().criteria.at(1));
+        ASSERT_EQ(inner1->get_parameters().max_iters, 5);
+        ASSERT_EQ(inner2->get_parameters().time_limit,
+                  std::chrono::nanoseconds(100));
+    } else if (auto inner1 = gko::as<gko::stop::Time::Factory>(
+                   inner->get_parameters().criteria.at(0))) {
+        auto inner2 = gko::as<gko::stop::Iteration::Factory>(
+            inner->get_parameters().criteria.at(1));
+        ASSERT_EQ(inner2->get_parameters().max_iters, 5);
+        ASSERT_EQ(inner1->get_parameters().time_limit,
+                  std::chrono::nanoseconds(100));
+    } else {
+        ASSERT_TRUE(false)
+            << "the first criterion is not ResidualNorm or Time.";
+    }
+}
+
+
 TEST_F(Config, MinimalConfigThrowWhenKeyIsInvalid)
 {
     pnode minimal_stop{{{"time", pnode{100}}, {"invalid", pnode{"no"}}}};

include/ginkgo/core/stop/iteration.hpp

@@ -108,7 +108,8 @@ deferred_factory_parameter<Iteration::Factory> max_iters(size_type count);
  *         `with_criteria` function when building a solver.
  */
 deferred_factory_parameter<CriterionFactory> min_iters(
-    size_type count, deferred_factory_parameter<CriterionFactory> criterion);
+    size_type count,
+    deferred_factory_parameter<const CriterionFactory> criterion);
 
 
 /**