batch_logger.hpp

// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_LOG_BATCH_LOGGER_HPP_
#define GKO_PUBLIC_CORE_LOG_BATCH_LOGGER_HPP_
 
 
#include <memory>
 
#include <ginkgo/core/base/batch_multi_vector.hpp>
#include <ginkgo/core/base/types.hpp>
#include <ginkgo/core/log/logger.hpp>
 
 
namespace gko {
namespace batch {
namespace log {
namespace detail {
 
 
template <typename ValueType>
struct log_data final {
    using real_type = remove_complex<ValueType>;
    using index_type = int;
 
    log_data(std::shared_ptr<const Executor> exec, size_type num_batch_items);
 
    log_data(std::shared_ptr<const Executor> exec, size_type num_batch_items,
             array<unsigned char>& workspace);
 
    array<real_type> res_norms;
 
    array<index_type> iter_counts;
};
 
 
}  // namespace detail
 
 
template <typename ValueType = default_precision>
class BatchConvergence final : public gko::log::Logger {
    GKO_ASSERT_SUPPORTED_VALUE_TYPE;
 
public:
    using real_type = remove_complex<ValueType>;
    using index_type = int;
    using mask_type = gko::log::Logger::mask_type;
 
    void on_batch_solver_completed(
        const array<index_type>& iteration_count,
        const array<real_type>& residual_norm) const override;
 
    static std::unique_ptr<BatchConvergence> create(
        const mask_type& enabled_events =
            gko::log::Logger::batch_solver_completed_mask)
    {
        return std::unique_ptr<BatchConvergence>(
            new BatchConvergence(enabled_events));
    }
 
    const array<index_type>& get_num_iterations() const noexcept
    {
        return iteration_count_;
    }
 
    const array<real_type>& get_residual_norm() const noexcept
    {
        return residual_norm_;
    }
 
protected:
    explicit BatchConvergence(const mask_type& enabled_events =
                                  gko::log::Logger::batch_solver_completed_mask)
        : gko::log::Logger(enabled_events)
    {}
 
private:
    mutable array<index_type> iteration_count_{};
    mutable array<real_type> residual_norm_{};
};
 
 
}  // namespace log
}  // namespace batch
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_LOG_BATCH_LOGGER_HPP_