rt_work_counter.hpp

Go to the documentation of this file.

#pragma once

 
#include <atomic>
#include <cmath>
#include <complex>
#include <cstdint>
 
#ifndef PULP_RT_WORK_COUNTERS
#define PULP_RT_WORK_COUNTERS 0
#endif
 
namespace pulp::signal::rt {

inline constexpr bool kWorkCountersEnabled = PULP_RT_WORK_COUNTERS != 0;

struct RtWorkCounts {
    std::uint64_t fft = 0;
    std::uint64_t trig = 0;
    std::uint64_t bins = 0;
 
    friend constexpr RtWorkCounts operator-(RtWorkCounts a,
                                            RtWorkCounts b) noexcept {
        return {a.fft - b.fft, a.trig - b.trig, a.bins - b.bins};
    }
    friend constexpr RtWorkCounts operator+(RtWorkCounts a,
                                            RtWorkCounts b) noexcept {
        return {a.fft + b.fft, a.trig + b.trig, a.bins + b.bins};
    }
    friend constexpr bool operator==(RtWorkCounts, RtWorkCounts) = default;
};
 
namespace detail {
#if PULP_RT_WORK_COUNTERS
inline std::atomic<std::uint64_t> g_fft_count{0};
inline std::atomic<std::uint64_t> g_trig_count{0};
inline std::atomic<std::uint64_t> g_bins_count{0};
#endif
} // namespace detail

inline void count_fft() noexcept {
#if PULP_RT_WORK_COUNTERS
    detail::g_fft_count.fetch_add(1, std::memory_order_relaxed);
#endif
}

inline void count_trig(std::uint64_t n = 1) noexcept {
#if PULP_RT_WORK_COUNTERS
    detail::g_trig_count.fetch_add(n, std::memory_order_relaxed);
#else
    (void)n;
#endif
}

inline void count_bins(std::uint64_t n) noexcept {
#if PULP_RT_WORK_COUNTERS
    detail::g_bins_count.fetch_add(n, std::memory_order_relaxed);
#else
    (void)n;
#endif
}

inline RtWorkCounts work_counts() noexcept {
#if PULP_RT_WORK_COUNTERS
    return {detail::g_fft_count.load(std::memory_order_relaxed),
            detail::g_trig_count.load(std::memory_order_relaxed),
            detail::g_bins_count.load(std::memory_order_relaxed)};
#else
    return {};
#endif
}

class RtWorkCounter {
public:
    RtWorkCounter() noexcept : start_(work_counts()) {}
    RtWorkCounts delta() const noexcept { return work_counts() - start_; }
    void restart() noexcept { start_ = work_counts(); }
 
private:
    RtWorkCounts start_;
};

template <typename T>
inline std::complex<T> polar(T magnitude, T phase) noexcept {
    count_trig();
    return std::polar(magnitude, phase);
}

template <typename T>
inline T sin(T x) noexcept {
    count_trig();
    return std::sin(x);
}

template <typename T>
inline T cos(T x) noexcept {
    count_trig();
    return std::cos(x);
}

template <typename T>
inline T exp(T x) noexcept {
    count_trig();
    return std::exp(x);
}

template <typename T>
inline T arg(const std::complex<T>& z) noexcept {
    count_trig();
    return std::arg(z);
}
 
} // namespace pulp::signal::rt