timer.hpp

// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_BASE_TIMER_HPP_
#define GKO_PUBLIC_CORE_BASE_TIMER_HPP_
 
 
#include <chrono>
 
#include <ginkgo/core/base/executor.hpp>
 
 
namespace gko {
 
 
class time_point {
public:
    ~time_point();
 
    time_point(time_point&&);
 
    time_point& operator=(time_point&&);
 
    time_point(const time_point&) = delete;
 
    time_point& operator=(const time_point&) = delete;
 
private:
    time_point();
 
    friend class Timer;
    friend class CpuTimer;
    friend class CudaTimer;
    friend class HipTimer;
    friend class DpcppTimer;
 
    enum class type {
        cpu,
        cuda,
        hip,
        dpcpp,
    };
 
    type type_;
    union data_union {
        CUevent_st* cuda_event;
        GKO_HIP_EVENT_STRUCT* hip_event;
        sycl::event* dpcpp_event;
        std::chrono::steady_clock::time_point chrono;
 
        data_union();
    } data_;
};
 
 
class Timer {
public:
    virtual ~Timer() = default;
 
    time_point create_time_point();
 
    virtual void record(time_point& time) = 0;
 
    virtual void wait(time_point& time) = 0;
 
    std::chrono::nanoseconds difference(time_point& start, time_point& stop);
 
    virtual std::chrono::nanoseconds difference_async(
        const time_point& start, const time_point& stop) = 0;
 
    static std::unique_ptr<Timer> create_for_executor(
        std::shared_ptr<const Executor> exec);
 
protected:
    virtual void init_time_point(time_point& time) = 0;
};
 
 
class CpuTimer : public Timer {
public:
    void record(time_point& time) override;
 
    void wait(time_point& time) override;
 
    std::chrono::nanoseconds difference_async(const time_point& start,
                                              const time_point& stop) override;
 
protected:
    void init_time_point(time_point& time) override;
};
 
 
class CudaTimer : public Timer {
public:
    void record(time_point& time) override;
 
    void wait(time_point& time) override;
 
    std::chrono::nanoseconds difference_async(const time_point& start,
                                              const time_point& stop) override;
 
    CudaTimer(std::shared_ptr<const CudaExecutor> exec);
 
protected:
    void init_time_point(time_point& time) override;
 
private:
    int device_id_;
    CUstream_st* stream_;
};
 
 
class HipTimer : public Timer {
public:
    void record(time_point& time) override;
 
    void wait(time_point& time) override;
 
    std::chrono::nanoseconds difference_async(const time_point& start,
                                              const time_point& stop) override;
 
    HipTimer(std::shared_ptr<const HipExecutor> exec);
 
protected:
    void init_time_point(time_point& time) override;
 
private:
    int device_id_;
    GKO_HIP_STREAM_STRUCT* stream_;
};
 
 
class DpcppTimer : public Timer {
public:
    void record(time_point& time) override;
 
    void wait(time_point& time) override;
 
    std::chrono::nanoseconds difference_async(const time_point& start,
                                              const time_point& stop) override;
 
    DpcppTimer(std::shared_ptr<const DpcppExecutor> exec);
 
protected:
    void init_time_point(time_point& time) override;
 
private:
    sycl::queue* queue_;
};
 
 
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_BASE_TIMER_HPP_