perf.h

Go to the documentation of this file.

#ifndef ZTH_PERF_H
#define ZTH_PERF_H
/*
 * SPDX-FileCopyrightText: 2019-2026 Jochem Rutgers
 *
 * SPDX-License-Identifier: MPL-2.0
 */
 
#include <libzth/macros.h>
 
#include <libzth/util.h>
 
typedef struct {
        void* p;
} zth_perf_async_handle_t;
 
typedef void(zth_perf_done_callback_t)();
typedef void(zth_perf_dump_callback_t)(void const*, size_t);
 
#ifdef __cplusplus
 
#  include <libzth/allocator.h>
#  include <libzth/config.h>
#  include <libzth/time.h>
 
#  include <cstdio>
#  include <cstdlib>
#  include <cstring>
 
namespace zth {
 
int perf_init();
void perf_deinit();
 
class Fiber;
 
ZTH_EXPORT void perf_start(zth_perf_done_callback_t* f = nullptr) noexcept;
ZTH_EXPORT void perf_stop() noexcept;
ZTH_EXPORT void perf_mark(char const* marker, Timestamp const& t = Timestamp()) noexcept;
ZTH_EXPORT __attribute__((format(ZTH_ATTR_PRINTF, 1, 0))) void
perf_logv(char const* fmt, va_list args, Timestamp const& t = Timestamp()) noexcept;
ZTH_EXPORT __attribute__((format(ZTH_ATTR_PRINTF, 1, 2))) void
perf_log(char const* fmt, ...) noexcept;
ZTH_EXPORT __attribute__((format(ZTH_ATTR_PRINTF, 2, 3))) void
perf_log(Timestamp const& t, char const* fmt, ...) noexcept;
ZTH_EXPORT void perf_dump(zth_perf_dump_callback_t* f) noexcept;
ZTH_EXPORT void perf_async_handle(zth_perf_async_handle_t* handle) noexcept;
ZTH_EXPORT void perf_mark_async(char const* marker, zth_perf_async_handle_t* handle) noexcept;
ZTH_EXPORT void perf_run(zth_perf_dump_callback_t* f) noexcept;
ZTH_EXPORT void perf_abort() noexcept;
ZTH_EXPORT void perf_run_dump(char const* path = nullptr) noexcept;
ZTH_EXPORT int perf_vcd(char const* perf = nullptr, char const* vcd = nullptr) noexcept;
ZTH_EXPORT int perf_vcdf(FILE* perf, FILE* vcd) noexcept;
 
inline void perf_syscall(char const* syscall, Timestamp const& t = Timestamp()) noexcept
{
        if(Config::EnablePerfEvent && zth_config(PerfSyscall))
                perf_mark(syscall, t);
}
 
void perf_fiber(Fiber& f) noexcept;
void perf_fiber_state(Fiber& f, int state = -1, Timestamp const& t = Timestamp()) noexcept;
 
template <typename T = float>
class Load {
        ZTH_CLASS_NEW_DELETE(Load)
public:
        typedef T type;
 
        explicit Load(type rc = 1) noexcept
                : m_rc(rc)
                , m_active()
                , m_current(Timestamp::now())
                , m_load()
        {}
 
        type rc() const noexcept
        {
                return m_rc;
        }
 
        void setRc(type rc) noexcept
        {
                m_rc = rc;
        }
 
        void start(Timestamp const& now = Timestamp::now()) noexcept
        {
                if(isActive())
                        return;
 
                idle((type)(now - m_current).s());
                m_current = now;
                m_active = true;
        }
 
        void stop(Timestamp const& now = Timestamp::now()) noexcept
        {
                if(!isActive())
                        return;
 
                active((type)(now - m_current).s());
                m_current = now;
                m_active = false;
        }
 
        bool isActive() const noexcept
        {
                return m_active;
        }
 
        type load() const noexcept
        {
                return m_load;
        }
 
        type load(Timestamp const& now) const noexcept
        {
                type dt_s = (type)(now - m_current).s();
                if(isActive())
                        return active(load(), dt_s);
                else
                        return idle(load(), dt_s);
        }
 
        void idle(type dt_s) noexcept
        {
                m_load = idle(load(), dt_s);
        }
 
        void active(type dt_s) noexcept
        {
                m_load = active(load(), dt_s);
        }
 
protected:
        type idle(type load, type dt_s) const noexcept
        {
                if(dt_s <= 0)
                        return load;
 
                return ((type)1 - alpha(dt_s)) * load;
        }
 
        type active(type load, type dt_s) const noexcept
        {
                if(dt_s <= 0)
                        return load;
 
                type a = alpha(dt_s);
                return a + ((type)1 - a) * load;
        }
 
        type alpha(type dt_s) const noexcept
        {
                return dt_s / (rc() + dt_s);
        }
 
private:
        type m_rc;
        bool m_active;
        Timestamp m_current;
        type m_load;
};
 
template <typename T = float, size_t Bins = 2, typename Count = uint_fast32_t>
class EventRate {
        ZTH_CLASS_NEW_DELETE(EventRate)
public:
        typedef T type;
        typedef Count count_type;
 
        explicit EventRate(type window = 1) noexcept
                : m_window_s(window)
                , m_window(window)
                , m_binStart()
                , m_bins()
                , m_current()
        {
                static_assert(std::numeric_limits<decltype(m_current)>::max() >= Bins, "");
        }
 
        void event(Timestamp const& now = Timestamp::now()) noexcept
        {
                size_t b = 0;
                for(; m_binStart + m_window < now && b < Bins; b++) {
                        // Proceed to next bin.
                        m_current = (m_current + 1U) % Bins;
                        m_bins[m_current] = 0;
                        m_binStart += m_window;
                }
 
                if(unlikely(b == Bins)) {
                        // Cleared all bins. Apparently, m_binStart was a long time ago.
                        m_binStart = now;
                }
 
                m_bins[m_current]++;
        }
 
        void operator()(Timestamp const& now = Timestamp::now()) noexcept
        {
                event(now);
        }
 
        type rate(Timestamp const& now = Timestamp::now()) const noexcept
        {
                type w = (type)(now - m_binStart).s() / m_window_s;
 
                if(unlikely(w > 1)) {
                        if(w > 2)
                                return 0; // We are really late.
 
                        w = 1;
                }
 
                // Scale the first bin, such that it is gradually removed from the average.
                type first_bin = ((type)1 - w) * (type)m_bins[(m_current + 1U) % Bins];
                // Last bin only holds events from [m_binStart,now[, no scaling required.
                type last_bin = (type)m_bins[m_current];
 
                // Sum all intermediate bins.
                type sum = first_bin + last_bin;
                for(decltype(m_current + 0) i = 2; i < Bins; i++)
                        sum += (type)m_bins[(m_current + i) % Bins];
 
                // As the first and last one are both partial, divide by Bins - 1.
                return sum * ((type)1 / (type)(Bins - 1)) / m_window_s;
        }
 
        operator type() const noexcept
        {
                return rate();
        }
 
private:
        type m_window_s;
        TimeInterval m_window;
        Timestamp m_binStart;
        count_type m_bins[Bins];
        uint8_t m_current;
};
 
} // namespace zth
 
EXTERN_C ZTH_EXPORT ZTH_INLINE void zth_perf_start(zth_perf_done_callback_t* f = nullptr) noexcept
{
        if(zth::Config::EnablePerfEvent)
                zth::perf_start(f);
}
 
EXTERN_C ZTH_EXPORT ZTH_INLINE void zth_perf_stop() noexcept
{
        if(zth::Config::EnablePerfEvent)
                zth::perf_stop();
}
 
EXTERN_C ZTH_EXPORT ZTH_INLINE void zth_perf_run(zth_perf_dump_callback_t* f) noexcept
{
        if(zth::Config::EnablePerfEvent)
                zth::perf_run(f);
}
 
EXTERN_C ZTH_EXPORT ZTH_INLINE void zth_perf_abort() noexcept
{
        if(zth::Config::EnablePerfEvent)
                zth::perf_abort();
}
 
EXTERN_C ZTH_EXPORT ZTH_INLINE void zth_perf_mark_(char const* marker) noexcept
{
        if(zth::Config::EnablePerfEvent)
                zth::perf_mark(marker);
}
 
EXTERN_C ZTH_EXPORT ZTH_INLINE __attribute__((format(ZTH_ATTR_PRINTF, 1, 0))) void
zth_perf_logv_(char const* fmt, va_list args) noexcept
{
        if(zth::Config::EnablePerfEvent)
                zth::perf_logv(fmt, args);
}
 
EXTERN_C ZTH_EXPORT ZTH_INLINE __attribute__((format(ZTH_ATTR_PRINTF, 1, 2))) void
zth_perf_log_(char const* fmt, ...) noexcept
{
        if(!zth::Config::EnablePerfEvent)
                return;
 
        va_list args;
        va_start(args, fmt);
        zth::perf_logv(fmt, args);
        va_end(args);
}
 
EXTERN_C ZTH_EXPORT ZTH_INLINE void zth_perf_dump(zth_perf_dump_callback_t* f) noexcept
{
        if(zth::Config::EnablePerfEvent)
                zth::perf_dump(f);
}
 
EXTERN_C ZTH_EXPORT ZTH_INLINE void zth_perf_async_handle(zth_perf_async_handle_t* handle) noexcept
{
        if(zth::Config::EnablePerfEvent)
                zth::perf_async_handle(handle);
}
 
EXTERN_C ZTH_EXPORT ZTH_INLINE void
zth_perf_mark_async_(char const* marker, zth_perf_async_handle_t* handle) noexcept
{
        if(zth::Config::EnablePerfEvent)
                zth::perf_mark_async(marker, handle);
}
 
EXTERN_C ZTH_EXPORT ZTH_INLINE int
zth_perf_vcd(char const* perf = nullptr, char const* vcd = nullptr) noexcept
{
        if(!zth::Config::EnablePerfEvent)
                return ENOSYS;
 
        return zth::perf_vcd(perf, vcd);
}
 
EXTERN_C ZTH_EXPORT ZTH_INLINE int zth_perf_vcdf(FILE* perf, FILE* vcd) noexcept
{
        if(!zth::Config::EnablePerfEvent)
                return ENOSYS;
 
        return zth::perf_vcdf(perf, vcd);
}
 
#else // !__cplusplus
 
#  include <stdarg.h>
#  include <stdio.h>
 
ZTH_EXPORT void zth_perf_start(zth_perf_done_callback_t* f);
ZTH_EXPORT void zth_perf_stop();
ZTH_EXPORT void zth_perf_mark_(char const* marker);
ZTH_EXPORT __attribute__((format(ZTH_ATTR_PRINTF, 1, 0))) void
zth_perf_logv(char const* fmt, va_list args);
ZTH_EXPORT __attribute__((format(ZTH_ATTR_PRINTF, 1, 2))) void zth_perf_log(char const* fmt, ...);
ZTH_EXPORT void zth_perf_dump(zth_perf_dump_callback_t* f);
ZTH_EXPORT void zth_perf_async_handle(zth_perf_async_handle_t* handle);
ZTH_EXPORT void zth_perf_mark_async_(char const* marker, zth_perf_async_handle_t* handle);
ZTH_EXPORT void zth_perf_run(zth_perf_dump_callback_t* f);
ZTH_EXPORT void zth_perf_abort();
ZTH_EXPORT int zth_perf_vcd(char const* perf, char const* vcd);
ZTH_EXPORT int zth_perf_vcdf(FILE* perf, FILE* vcd);
 
#endif // __cplusplus
 
#define zth_perf_mark(marker) zth_perf_mark_("" marker)
 
#define zth_perf_logv(fmt, args) zth_perf_logv_("" fmt, args)
 
#define zth_perf_log(fmt, ...) zth_perf_log_("" fmt, ##__VA_ARGS__)
 
#define zth_perf_mark_async(marker, handle) zth_perf_mark_async("" marker, (handle))
 
#endif // ZTH_PERF_H