time.hpp

Go to the documentation of this file.

// -------------------------------------------------------//
//
// SHAMROCK code for hydrodynamics
// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
//
// -------------------------------------------------------//
 
#pragma once

 
#include "shambase/aliases_float.hpp"
#include "shambase/string.hpp"
#include <functional>
#include <iostream>
 
#ifndef __MACH__
    #include <plf_nanotimer.h>
#else
    #include <chrono>
#endif
 
namespace shambase {

    class Timer {
        public:
#if defined(__MACH__)
        std::chrono::steady_clock::time_point t_start; 
#else
        plf::nanotimer timer; 
#endif
        f64 nanosec; 

        Timer() : nanosec(0.0) {}

        inline void start() {
#if defined(__MACH__)
            t_start = std::chrono::steady_clock::now();
#else
            timer.start();
#endif
        }

        inline void stop() {
#if defined(__MACH__)
            auto t_end = std::chrono::steady_clock::now();
            nanosec    = f64(
                std::chrono::duration_cast<std::chrono::nanoseconds>(t_end - t_start).count());
#else
            nanosec = f64(timer.get_elapsed_ns());
#endif
        }

        inline std::string get_time_str() const {
            auto res = sham::to_human_readable(nanosec * 1e-9);
            return sham::format("{:.2f} {}s", res.value, res.prefix);
        }

        [[nodiscard]] inline f64 elapsed_sec() const { return nanosec * 1e-9; }
    };

    class FunctionTimer {
        f64 acc = 0;
        u32 run_count = 0;
 
        public:
        template<class Func>
        void time_func(Func &&f) {
            Timer t;
            t.start();
            f();
            t.stop();
            acc += t.elapsed_sec();
            run_count += 1;
        }

        inline f64 func_time_sec() { return acc / run_count; }
    };

    template<class Func>
    inline f64 timeit(Func &&f, u32 relaunch = 1) {
 
        FunctionTimer t;
 
        for (u32 i = 0; i < relaunch; i++) {
            t.time_func([&]() {
                f();
            });
        }
 
        return t.func_time_sec();
    }

    template<class Func>
    inline f64 timeitfor(Func &&f, f64 max_duration = 1) {
 
        FunctionTimer t;
        Timer tdur;
        tdur.start();
        do {
            t.time_func([&]() {
                f();
            });
            tdur.stop();
        } while (tdur.elapsed_sec() < max_duration);
 
        return t.func_time_sec();
    }

    struct BenchmarkResult {
        std::vector<f64> counts;

        std::vector<f64> times;
    };

    inline BenchmarkResult benchmark_pow_len(
        std::function<f64(u32)> func, u32 start, u32 end, f64 pow_exp) {
        BenchmarkResult res;
        for (f64 i = start; i < end; i *= pow_exp) {
            res.counts.push_back(i);
            res.times.push_back(func(u32(i)));
        }
 
        return res;
    }
 
} // namespace shambase