CpuLoad.hxx

Go to the documentation of this file.

 
#include "openmrn_features.h"
 
#ifdef OPENMRN_FEATURE_THREAD_FREERTOS
 
#ifndef _OS_CPULOAD_HXX_
#define _OS_CPULOAD_HXX_
 
#include <algorithm>
 
#include "executor/StateFlow.hxx"
#include "utils/SimpleQueue.hxx"
#include "utils/Singleton.hxx"
#include "utils/StringPrintf.hxx"
#include "freertos_includes.h"
 
extern "C" {
    void cpuload_tick(unsigned irq);
}
 
class CpuLoad : public Singleton<CpuLoad> {
public:
    CpuLoad() {}
 
    ~CpuLoad()
    {
        while (!perKeyCost_.empty())
        {
            delete perKeyCost_.pop_front();
        }
    }
 
    uint8_t get_load();
 
    uint8_t get_max_consecutive() {
        return maxConsecutive_;
    }
 
    void clear_max_consecutive() {
        maxConsecutive_ = 0;
    }
 
    uint8_t get_peak_over_16_counts() {
        return peakOver16Counts_;
    }
 
    void clear_peak_over_16_counts() {
        peakOver16Counts_ = 0;
    }
 
    uintptr_t new_key()
    {
        auto k = newKey_;
        newKey_ = 0;
        return k;
    }
 
    void set_key_description(uintptr_t key, string description)
    {
        auto it = perKeyCost_.begin();
        for (; it != perKeyCost_.end(); ++it)
        {
            if (it->key == key)
            {
                it->description = std::move(description);
                return;
            }
        }
        auto *kk = new KeyInfo;
        kk->key = key;
        kk->description = std::move(description);
        perKeyCost_.insert(it, kk);
    }
 
    uint32_t get_utilization_delta(
        std::vector<pair<unsigned, string *>> *output)
    {
        HASSERT(output);
        output->clear();
        for (auto it = perKeyCost_.begin(); it != perKeyCost_.end(); ++it)
        {
            volatile unsigned curr = it->rolling_count;
            unsigned diff = curr - it->last_count;
            it->last_count = curr;
            if (diff > 0)
            {
                output->emplace_back(diff, &it->description);
            }
        }
        uint32_t ret = countSinceUpdate_;
        countSinceUpdate_ = 0;
        return ret;
    }
 
private:
    friend void cpuload_tick(unsigned);
    inline void record_value(bool busy, uintptr_t key);
 
    uint32_t avg_{0};
 
    uint32_t countSinceUpdate_{0};
 
    uintptr_t newKey_{0};
 
    struct KeyInfo : public QMember
    {
        uintptr_t key;
        string description;
        uint32_t last_count{0};
        uint32_t rolling_count{0};
    };
 
    TypedQueue<KeyInfo> perKeyCost_;
 
    uint8_t consecutive_{0};
    uint8_t maxConsecutive_{0};
    uint16_t last16Bits_{0};
    uint8_t peakOver16Counts_{0};
};
 
class CpuLoadLog : public StateFlowBase
{
public:
    CpuLoadLog(Service *service)
        : StateFlowBase(service)
    {
        start_flow(STATE(log_and_wait));
    }
 
private:
    Action log_and_wait()
    {
        auto *l = CpuLoad::instance();
        uint32_t ex_count = service()->executor()->sequence();
        LOG(INFO,
            "Ex %d|FreeHeap %d|Buf %d|Load: avg %3d max streak %d max of 16 %d",
            (int)(ex_count - executorLastCount_), (int)os_get_free_heap(),
            (int)mainBufferPool->total_size(), l->get_load(),
            l->get_max_consecutive(), l->get_peak_over_16_counts());
        executorLastCount_ = ex_count;
        l->clear_max_consecutive();
        l->clear_peak_over_16_counts();
        vector<pair<unsigned, string *>> per_task_ticks;
        unsigned c = l->get_utilization_delta(&per_task_ticks);
        std::sort(per_task_ticks.begin(), per_task_ticks.end(),
                  std::greater<decltype(per_task_ticks)::value_type>());
        string details;
        for (volatile auto it : per_task_ticks)
        {
            int perc = it.first * 1000 / c;
            details += StringPrintf(" | %d.%d:", perc / 10, perc % 10);
            details += *it.second;
        }
        log_output((char *)details.data(), details.size());
        auto k = l->new_key();
        if (k < 300)
        {
            l->set_key_description(k, StringPrintf("irq-%u", (unsigned)k));
        }
        else if (k & 1)
        {
            l->set_key_description(
                k, StringPrintf("ex 0x%x", (unsigned)(k & ~1)));
        }
        else
        {
#if tskKERNEL_VERSION_MAJOR < 9
            char *name = pcTaskGetTaskName((TaskHandle_t)k);
#else
            char *name = pcTaskGetName((TaskHandle_t)k);
#endif            
            l->set_key_description(k, name);
        }
        return sleep_and_call(&timer_, MSEC_TO_NSEC(2000), STATE(log_and_wait));
    }
 
    uint32_t executorLastCount_{0};
    StateFlowTimer timer_{this};
};
 
#endif // _OS_CPULOAD_HXX_
#endif // OPENMRN_FEATURE_THREAD_FREERTOS