logger.hpp

/*******************************<GINKGO LICENSE>******************************
Copyright (c) 2017-2019, 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>*******************************/

#ifndef GKO_CORE_LOGGER_HPP_
#define GKO_CORE_LOGGER_HPP_


#include <algorithm>
#include <memory>
#include <string>
#include <vector>


#include <ginkgo/core/base/std_extensions.hpp>
#include <ginkgo/core/base/types.hpp>
#include <ginkgo/core/base/utils.hpp>


namespace gko {


/* Eliminate circular dependencies the hard way */
template <typename ValueType>
class Array;
class Executor;
class LinOp;
class LinOpFactory;
class PolymorphicObject;
class Operation;
class stopping_status;

namespace stop {
class Criterion;
}  // namespace stop


namespace log {


class Logger {
public:
    using mask_type = gko::uint64;

    static constexpr size_type event_count_max = sizeof(mask_type) * byte_size;

    static constexpr mask_type all_events_mask = ~mask_type{0};

#define GKO_LOGGER_REGISTER_EVENT(_id, _event_name, ...)             \
protected:                                                           \
    virtual void on_##_event_name(__VA_ARGS__) const {}              \
                                                                     \
public:                                                              \
    template <size_type Event, typename... Params>                   \
    xstd::enable_if_t<Event == _id && (_id < event_count_max)> on(   \
        Params &&... params) const                                   \
    {                                                                \
        if (enabled_events_ & (mask_type{1} << _id)) {               \
            this->on_##_event_name(std::forward<Params>(params)...); \
        }                                                            \
    }                                                                \
    static constexpr size_type _event_name{_id};                     \
    static constexpr mask_type _event_name##_mask{mask_type{1} << _id};

    GKO_LOGGER_REGISTER_EVENT(0, allocation_started, const Executor *exec,
                              const size_type &num_bytes)

    
    GKO_LOGGER_REGISTER_EVENT(1, allocation_completed, const Executor *exec,
                              const size_type &num_bytes,
                              const uintptr &location)

    
    GKO_LOGGER_REGISTER_EVENT(2, free_started, const Executor *exec,
                              const uintptr &location)

    
    GKO_LOGGER_REGISTER_EVENT(3, free_completed, const Executor *exec,
                              const uintptr &location)

    
    GKO_LOGGER_REGISTER_EVENT(4, copy_started, const Executor *exec_from,
                              const Executor *exec_to, const uintptr &loc_from,
                              const uintptr &loc_to, const size_type &num_bytes)

    
    GKO_LOGGER_REGISTER_EVENT(5, copy_completed, const Executor *exec_from,
                              const Executor *exec_to, const uintptr &loc_from,
                              const uintptr &loc_to, const size_type &num_bytes)

    
    GKO_LOGGER_REGISTER_EVENT(6, operation_launched, const Executor *exec,
                              const Operation *op)

    
    GKO_LOGGER_REGISTER_EVENT(7, operation_completed, const Executor *exec,
                              const Operation *op)

    
    GKO_LOGGER_REGISTER_EVENT(8, polymorphic_object_create_started,
                              const Executor *exec, const PolymorphicObject *po)

    
    GKO_LOGGER_REGISTER_EVENT(9, polymorphic_object_create_completed,
                              const Executor *exec,
                              const PolymorphicObject *input,
                              const PolymorphicObject *output)

    
    GKO_LOGGER_REGISTER_EVENT(10, polymorphic_object_copy_started,
                              const Executor *exec,
                              const PolymorphicObject *input,
                              const PolymorphicObject *output)

    
    GKO_LOGGER_REGISTER_EVENT(11, polymorphic_object_copy_completed,
                              const Executor *exec,
                              const PolymorphicObject *input,
                              const PolymorphicObject *output)

    
    GKO_LOGGER_REGISTER_EVENT(12, polymorphic_object_deleted,
                              const Executor *exec, const PolymorphicObject *po)

    
    GKO_LOGGER_REGISTER_EVENT(13, linop_apply_started, const LinOp *A,
                              const LinOp *b, const LinOp *x)

    
    GKO_LOGGER_REGISTER_EVENT(14, linop_apply_completed, const LinOp *A,
                              const LinOp *b, const LinOp *x)

    
    GKO_LOGGER_REGISTER_EVENT(15, linop_advanced_apply_started, const LinOp *A,
                              const LinOp *alpha, const LinOp *b,
                              const LinOp *beta, const LinOp *x)

    
    GKO_LOGGER_REGISTER_EVENT(16, linop_advanced_apply_completed,
                              const LinOp *A, const LinOp *alpha,
                              const LinOp *b, const LinOp *beta, const LinOp *x)

    
    GKO_LOGGER_REGISTER_EVENT(17, linop_factory_generate_started,
                              const LinOpFactory *factory, const LinOp *input)

    
    GKO_LOGGER_REGISTER_EVENT(18, linop_factory_generate_completed,
                              const LinOpFactory *factory, const LinOp *input,
                              const LinOp *output)

    
    GKO_LOGGER_REGISTER_EVENT(19, criterion_check_started,
                              const stop::Criterion *criterion,
                              const size_type &it, const LinOp *r,
                              const LinOp *tau, const LinOp *x,
                              const uint8 &stopping_id,
                              const bool &set_finalized)

    
    GKO_LOGGER_REGISTER_EVENT(
        20, criterion_check_completed, const stop::Criterion *criterion,
        const size_type &it, const LinOp *r, const LinOp *tau, const LinOp *x,
        const uint8 &stopping_id, const bool &set_finalized,
        const Array<stopping_status> *status, const bool &one_changed,
        const bool &all_converged)

    
    GKO_LOGGER_REGISTER_EVENT(21, iteration_complete, const LinOp *solver,
                              const size_type &it, const LinOp *r,
                              const LinOp *x = nullptr,
                              const LinOp *tau = nullptr)


#undef GKO_LOGGER_REGISTER_EVENT

    static constexpr mask_type executor_events_mask =
        allocation_started_mask | allocation_completed_mask |
        free_started_mask | free_completed_mask | copy_started_mask |
        copy_completed_mask;

    static constexpr mask_type operation_events_mask =
        operation_launched_mask | operation_completed_mask;

    static constexpr mask_type polymorphic_object_events_mask =
        polymorphic_object_create_started_mask |
        polymorphic_object_create_completed_mask |
        polymorphic_object_copy_started_mask |
        polymorphic_object_copy_completed_mask |
        polymorphic_object_deleted_mask;

    static constexpr mask_type linop_events_mask =
        linop_apply_started_mask | linop_apply_completed_mask |
        linop_advanced_apply_started_mask | linop_advanced_apply_completed_mask;

    static constexpr mask_type linop_factory_events_mask =
        linop_factory_generate_started_mask |
        linop_factory_generate_completed_mask;

    static constexpr mask_type criterion_events_mask =
        criterion_check_started_mask | criterion_check_completed_mask;

protected:
    explicit Logger(std::shared_ptr<const gko::Executor> exec,
                    const mask_type &enabled_events = all_events_mask)
        : exec_{exec}, enabled_events_{enabled_events}
    {}

private:
    std::shared_ptr<const Executor> exec_;
    mask_type enabled_events_;
};


class Loggable {
public:
    virtual ~Loggable() = default;

    virtual void add_logger(std::shared_ptr<const Logger> logger) = 0;

    virtual void remove_logger(const Logger *logger) = 0;
};


template <typename ConcreteLoggable, typename PolymorphicBase = Loggable>
class EnableLogging : public Loggable {
public:
    void add_logger(std::shared_ptr<const Logger> logger) override
    {
        loggers_.push_back(logger);
    }

    void remove_logger(const Logger *logger) override
    {
        auto idx = find_if(begin(loggers_), end(loggers_),
                           [&logger](std::shared_ptr<const Logger> l) {
                               return lend(l) == logger;
                           });
        if (idx != end(loggers_)) {
            loggers_.erase(idx);
        } else {
            throw OutOfBoundsError(__FILE__, __LINE__, loggers_.size(),
                                   loggers_.size());
        }
    }

protected:
    template <size_type Event, typename... Params>
    void log(Params &&... params) const
    {
        for (auto &logger : loggers_) {
            logger->template on<Event>(std::forward<Params>(params)...);
        }
    }

    std::vector<std::shared_ptr<const Logger>> loggers_;
};


}  // namespace log
}  // namespace gko


#endif  // GKO_CORE_LOGGER_HPP_