Valentin V. Bartenev
482b31bc19
Previously _onSample() computed and stored a volatile float _sma_avg
on every sample (64 times/minute on core 0). The getter simply returned
that pre-computed value.
This commit inverts the responsibility:
- _sma_sum is now volatile uint16_t — the raw integer sum is the
cross-core shared state, written atomically by core 0 (single S16I
instruction on Xtensa LX7) and read by core 1.
- The float conversion (uint16_t → float multiply) is moved into
getCore0Util(), which is called rarely (once/minute for history,
on-demand for web requests). The multiply now happens on the core
that actually needs the result.
- _sma_avg is removed entirely, saving 4 bytes and one volatile float
store per sample from the hot path.
- The SMA update is rewritten as a single combined expression:
const uint16_t last = _sma_buf[_sma_idx];
_sma_buf[_sma_idx] = s8;
_sma_sum = (_sma_sum - last) + s8;
This produces a single write to _sma_sum instead of two (decrement
then increment), which is cleaner when _sma_sum is volatile.
The cross-core contract is unchanged: core 0 writes _sma_sum once per
sample; core 1 reads it in getCore0Util(). A 16-bit aligned store on
Xtensa LX7 is a single instruction, so no spinlock is needed.
54 lines
1.5 KiB
C++
54 lines
1.5 KiB
C++
#ifdef ESP32
|
|
#include "CPUUsageTracker.h"
|
|
#include "esp_freertos_hooks.h"
|
|
|
|
volatile uint32_t CPUUsageTracker::s_idle_ticks = 0;
|
|
volatile uint32_t CPUUsageTracker::s_busy_ticks = 0;
|
|
TaskHandle_t CPUUsageTracker::s_idle_handle = nullptr;
|
|
|
|
void IRAM_ATTR CPUUsageTracker::s_tick_hook() {
|
|
if (xTaskGetCurrentTaskHandle() == s_idle_handle) {
|
|
s_idle_ticks++;
|
|
} else {
|
|
s_busy_ticks++;
|
|
}
|
|
}
|
|
|
|
void CPUUsageTracker::s_sample_cb(void* arg) {
|
|
static_cast<CPUUsageTracker*>(arg)->_onSample();
|
|
}
|
|
|
|
void CPUUsageTracker::_onSample() {
|
|
const uint32_t busy = s_busy_ticks;
|
|
const uint32_t idle = s_idle_ticks;
|
|
const uint32_t db = busy - _last_busy;
|
|
const uint32_t di = idle - _last_idle;
|
|
_last_busy = busy;
|
|
_last_idle = idle;
|
|
|
|
const uint32_t total = db + di;
|
|
const float sample = (total > 0) ? (float)db / (float)total : 0.0f;
|
|
|
|
const uint8_t s8 = (uint8_t)(sample * 255.0f + 0.5f);
|
|
const uint16_t last = _sma_buf[_sma_idx];
|
|
_sma_buf[_sma_idx] = s8;
|
|
_sma_sum = (_sma_sum - last) + s8;
|
|
_sma_idx = (_sma_idx + 1) & (SMA_WINDOW - 1);
|
|
}
|
|
|
|
void CPUUsageTracker::begin() {
|
|
s_idle_handle = xTaskGetIdleTaskHandleForCPU(0);
|
|
esp_register_freertos_tick_hook_for_cpu(s_tick_hook, 0);
|
|
|
|
esp_timer_create_args_t args = {
|
|
.callback = s_sample_cb,
|
|
.arg = this,
|
|
.dispatch_method = ESP_TIMER_TASK,
|
|
.name = "cpu_sample"
|
|
};
|
|
esp_timer_create(&args, &_timer);
|
|
esp_timer_start_periodic(_timer, 60000000ULL / SMA_WINDOW); // SMA_WINDOW samples per minute
|
|
}
|
|
|
|
#endif
|