TimerListener.hpp

Go to the documentation of this file.

#ifndef KOKKOS_UTILS_CALLBACKS_TIMERLISTENER_HPP
#define KOKKOS_UTILS_CALLBACKS_TIMERLISTENER_HPP
 
#include "kokkos-utils/callbacks/Listener.hpp"
#include "kokkos-utils/callbacks/Matcher.hpp"
 
namespace Kokkos::utils::callbacks
{
 
template <typename TimerType>
concept Startable = requires (TimerType& timer) {
    { timer.start() } -> std::same_as<void>;
};
 
template <typename TimerType, typename EventType>
concept StartableWithEvent = requires (TimerType& timer, const EventType& event) {
    { timer.start(event) } -> std::same_as<void>;
};
 
template <typename TimerType>
concept Stoppable = requires (TimerType& timer) {
    { timer.stop() } -> std::same_as<void>;
};
 
template <typename TimerType, typename EventType>
concept StoppableWithEvent = requires (TimerType& timer, const EventType& event) {
    { timer.stop(event) } -> std::same_as<void>;
};

template <
    Matcher BeginEndMatcherType,
    typename TimerType
>
struct TimerListener
{
    template <Event EventType> requires MatcherFor<BeginEndMatcherType, EventType>
    void operator()(const EventType& event)
    {
        if(closed()) return;
 
        const bool matching = matcher(event);

        if(!this->matched_begin && matching)
        {
            this->matched_begin = true;
 
            if constexpr (Startable<TimerType>) {
                this->timer.start();
            } else if constexpr (StartableWithEvent<TimerType, EventType>) {
                this->timer.start(event);
            }
        }
        else if(this->matched_begin && ! this->matched_end && matching)
        {
            this->matched_end = true;
 
            if constexpr (Stoppable<TimerType>) {
                this->timer.stop();
            } else if constexpr (StoppableWithEvent<TimerType, EventType>) {
                this->timer.stop(event);
            }
        }
    }

    bool connected() const { return matched_begin && !matched_end; }

    bool closed() const { return matched_begin && matched_end; }

    void reset() {
        matched_begin = matched_end = false;
    }
 
    BeginEndMatcherType matcher {};
    TimerType timer {};
    bool matched_begin = false;
    bool matched_end   = false;
};
 
} // namespace Kokkos::utils::callbacks
 
#endif // KOKKOS_UTILS_CALLBACKS_TIMERLISTENER_HPP