time.hpp

// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_STOP_TIME_HPP_
#define GKO_PUBLIC_CORE_STOP_TIME_HPP_
 
 
#include <chrono>
 
#include <ginkgo/core/base/abstract_factory.hpp>
#include <ginkgo/core/stop/criterion.hpp>
 
 
namespace gko {
namespace stop {
 
class Time : public Criterion {
public:
    using clock = std::chrono::steady_clock;
 
    GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
    {
        std::chrono::nanoseconds GKO_FACTORY_PARAMETER_SCALAR(time_limit,
                                                              10000000000LL);
    };
    GKO_ENABLE_CRITERION_FACTORY(Time, parameters, Factory);
    GKO_ENABLE_BUILD_METHOD(Factory);
 
protected:
    bool check_impl(uint8 stoppingId, bool setFinalized,
                    array<stopping_status>* stop_status, bool* one_changed,
                    const Updater&) override;
 
    explicit Time(std::shared_ptr<const gko::Executor> exec)
        : Criterion(std::move(exec)), time_limit_{}, start_{}
    {}
 
    explicit Time(const Factory* factory, const CriterionArgs args)
        : Criterion(factory->get_executor()),
          parameters_{factory->get_parameters()},
          time_limit_{std::chrono::duration<double>(
              factory->get_parameters().time_limit)},
          start_{clock::now()}
    {}
 
private:
    std::chrono::duration<double> time_limit_;
    clock::time_point start_;
};
 
 
deferred_factory_parameter<Time::Factory> time_limit(
    std::chrono::nanoseconds duration);
 
 
}  // namespace stop
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_STOP_TIME_HPP_