CpuLoad.cxx

 
#include "CpuLoad.hxx"
 
#ifdef OPENMRN_FEATURE_THREAD_FREERTOS
 
#include "os/os.h"
#include "freertos_includes.h"
 
#ifdef ESP32
#include "sdkconfig.h"
#endif // ESP32
 
extern "C"
{
 
static constexpr uint32_t SHIFT_ONE = 24;
 
static constexpr uint32_t SHIFT_RATE = 8;
static constexpr uint8_t AVG_RATE = 0xff;
static constexpr uint32_t ADD_RATE = 0x1 << 24;
 
void CpuLoad::record_value(bool busy, uintptr_t key)
{
    avg_ *= AVG_RATE;
    ++countSinceUpdate_;
    if (busy)
    {
        avg_ += ADD_RATE;
    }
    avg_ >>= SHIFT_RATE;
    // Check streak
    if (busy)
    {
        if (consecutive_ < 255)
        {
            ++consecutive_;
        }
        if (consecutive_ > maxConsecutive_)
        {
            maxConsecutive_ = consecutive_;
        }
    }
    else
    {
        consecutive_ = 0;
    }
    // Check window of 16.
    last16Bits_ <<= 1;
    last16Bits_ |= (busy ? 1 : 0);
    // sums up last 16 bits.
    unsigned v = last16Bits_;
    v = (v & 0x5555) + ((v & 0xaaaa) >> 1);
    v = (v & 0x3333) + ((v & 0xcccc) >> 2);
    v = (v & 0x0F0F) + ((v & 0xF0F0) >> 4);
    v = (v & 0x00FF) + ((v & 0xFF00) >> 8);
    if (v > peakOver16Counts_)
    {
        peakOver16Counts_ = v;
    }
    // Record per-key information
    if (key == 0)
        return;
    bool found = false;
    for (auto it = perKeyCost_.begin(); it != perKeyCost_.end(); ++it)
    {
        if (it->key == key)
        {
            found = true;
            ++it->rolling_count;
            break;
        }
    }
    if (!found && newKey_ == 0)
    {
        newKey_ = key;
    }
}
 
uint8_t CpuLoad::get_load() {
    return (avg_ * 100) >> SHIFT_ONE;
}
 
void cpuload_tick(unsigned irq)
{
    if (!Singleton<CpuLoad>::exists())
        return;
// On the ESP32 it is necessary to use a slightly different approach for
// recording CPU usage metrics since there may be additional CPU cores.
#ifdef ESP32
    if (irq != 0)
    {
        Singleton<CpuLoad>::instance()->record_value(true, (uintptr_t)irq);
    }
    else
    {
        // Record the first CPU core (PRO_CPU). NOTE: This assumes that OpenMRN
        // is running on this core.
        auto hdl = xTaskGetCurrentTaskHandleForCPU(PRO_CPU_NUM);
        bool is_idle = xTaskGetIdleTaskHandleForCPU(PRO_CPU_NUM) == hdl;
        Singleton<CpuLoad>::instance()->record_value(!is_idle, (uintptr_t)hdl);
    }
// NOTE: The ESP32-S2 and ESP32-C3 are single-core SoC and defines the
// FREERTOS_UNICORE flag which we can use here to disable recording of the
// APP_CPU.
#ifndef CONFIG_FREERTOS_UNICORE
    // Record the second CPU core (APP_CPU). NOTE: this is where application
    // code typically runs.
    auto hdl = xTaskGetCurrentTaskHandleForCPU(APP_CPU_NUM);
    bool is_idle = xTaskGetIdleTaskHandleForCPU(APP_CPU_NUM) == hdl;
    Singleton<CpuLoad>::instance()->record_value(!is_idle, (uintptr_t)hdl);
#endif // CONFIG_FREERTOS_UNICORE
#else // NOT ESP32
    if (irq != 0)
    {
        Singleton<CpuLoad>::instance()->record_value(true, (uintptr_t)irq);
        return;
    }
    auto hdl = xTaskGetCurrentTaskHandle();
    bool is_idle = xTaskGetIdleTaskHandle() == hdl;
    Singleton<CpuLoad>::instance()->record_value(!is_idle, (uintptr_t)hdl);
#endif // ESP32
}
} // extern "C"
 
DEFINE_SINGLETON_INSTANCE(CpuLoad);
 
#endif // OPENMRN_FEATURE_THREAD_FREERTOS