debug: Add cpu_load module

Add module which can measure CPU idle time. Idle time is measured in
the pre/post CPU idle hooks but they are not provided by this module.

Signed-off-by: Krzysztof Chruściński <krzysztof.chruscinski@nordicsemi.no>

Author: nordic-krch

include/zephyr/debug/cpu_load.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2024, Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef ZEPHYR_INCLUDE_DEBUG_CPU_LOAD_H_
+#define ZEPHYR_INCLUDE_DEBUG_CPU_LOAD_H_
+
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @defgroup cpu_load CPU load monitor
+ *  @ingroup os_services
+ *  @brief Module for monitoring CPU Load
+ *
+ *  This module allow monitoring of the CPU load.
+ *  @{
+ */
+
+/** @brief Hook called by the application specific hook on entering CPU idle. */
+void cpu_load_on_enter_idle(void);
+
+/** @brief Hook called by the application specific hook on exiting CPU idle. */
+void cpu_load_on_exit_idle(void);
+
+/** @brief Get CPU load.
+ *
+ * CPU load is measured using a timer which tracks amount of time spent in the
+ * CPU idle. Since it is a software tracking there is some small overhead.
+ * Precision depends on the frequency of the timer in relation to the CPU frequency.
+ *
+ * @param reset Reset the measurement after reading.
+ *
+ * @retval Positive number - CPU load in per mille.
+ * @retval Negative number - error code.
+ */
+int cpu_load_get(bool reset);
+
+/** @brief Control periodic CPU statistics report.
+ *
+ * Report logging is by default enabled.
+ *
+ * @param enable true to enable report logging and false to disable.
+ */
+void cpu_load_log_control(bool enable);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* ZEPHYR_INCLUDE_DEBUG_CPU_LOAD_H_ */

subsys/debug/CMakeLists.txt

@@ -39,3 +39,8 @@ zephyr_sources_ifdef(
   CONFIG_CS_TRACE_DEFMT
   coresight/cs_trace_defmt.c
 )
+
+zephyr_sources_ifdef(
+  CONFIG_CPU_LOAD
+  cpu_load.c
+  )

subsys/debug/Kconfig

@@ -431,3 +431,27 @@ config CS_TRACE_DEFMT
 	help
 	  Module is decoding data which is formatted using Coresight
 	  Trace Formatter, e.g. when data is put into ETR (Embedded Trace Router).
+
+config CPU_LOAD
+	select TRACING
+	# Currently hooks are added only to Cortex M architecture.
+	depends on CPU_CORTEX_M
+	bool "CPU load measurement"
+
+# Workaround for not being able to have commas in macro arguments
+DT_CHOSEN_Z_CPU_LOAD_COUNTER := zephyr,cpu-load-counter
+
+config CPU_LOAD_USE_COUNTER
+	bool "Use counter"
+	depends on $(dt_chosen_enabled,DT_CHOSEN_Z_CPU_LOAD_COUNTER)
+	default y
+	select COUNTER
+	help
+	  Use counter for tracking CPU idle time.
+
+config CPU_LOAD_LOG_PERIODICALLY
+	int "Report period (in milliseconds)"
+	depends on LOG
+	default 0
+	help
+	  Specifies how often CPU load shall be logged. 0 means that there is no logging.

subsys/debug/cpu_load.c

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2024, Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <zephyr/debug/cpu_load.h>
+#include <zephyr/kernel.h>
+#include <zephyr/drivers/counter.h>
+#include <zephyr/logging/log.h>
+LOG_MODULE_REGISTER(cpu_load);
+
+BUILD_ASSERT(!IS_ENABLED(CONFIG_CPU_LOAD_USE_COUNTER) || DT_HAS_CHOSEN(zephyr_cpu_load_counter));
+
+#ifndef CONFIG_CPU_LOAD_LOG_PERIODICALLY
+#define CONFIG_CPU_LOAD_LOG_PERIODICALLY 0
+#endif
+
+const struct device *counter = COND_CODE_1(CONFIG_CPU_LOAD_USE_COUNTER,
+				(DEVICE_DT_GET(DT_CHOSEN(zephyr_cpu_load_counter))), (NULL));
+static uint32_t enter_ts;
+static uint32_t cyc_start;
+static uint32_t ticks_idle;
+
+static struct k_work_delayable cpu_load_log;
+
+void cpu_load_log_control(bool enable)
+{
+	if (CONFIG_CPU_LOAD_LOG_PERIODICALLY == 0) {
+		return;
+	}
+
+	if (enable) {
+		(void)cpu_load_get(true);
+		k_work_schedule(&cpu_load_log, K_MSEC(CONFIG_CPU_LOAD_LOG_PERIODICALLY));
+	} else {
+		k_work_cancel_delayable(&cpu_load_log);
+	}
+}
+
+#if CONFIG_CPU_LOAD_USE_COUNTER || CONFIG_CPU_LOAD_LOG_PERIODICALLY
+static void cpu_load_log_fn(struct k_work *work)
+{
+	int load = cpu_load_get(true);
+	uint32_t percent = load / 10;
+	uint32_t fraction = load % 10;
+
+	LOG_INF("Load:%d.%03d%%", percent, fraction);
+	cpu_load_log_control(true);
+}
+
+static int cpu_load_init(void)
+{
+	if (IS_ENABLED(CONFIG_CPU_LOAD_USE_COUNTER)) {
+		int err = counter_start(counter);
+
+		(void)err;
+		__ASSERT_NO_MSG(err == 0);
+	}
+
+	if (CONFIG_CPU_LOAD_LOG_PERIODICALLY > 0) {
+		k_work_init_delayable(&cpu_load_log, cpu_load_log_fn);
+		return k_work_schedule(&cpu_load_log, K_MSEC(CONFIG_CPU_LOAD_LOG_PERIODICALLY));
+	}
+
+	return 0;
+}
+
+SYS_INIT(cpu_load_init, POST_KERNEL, 0);
+#endif
+
+void cpu_load_on_enter_idle(void)
+{
+	if (IS_ENABLED(CONFIG_CPU_LOAD_USE_COUNTER)) {
+		counter_get_value(counter, &enter_ts);
+		return;
+	}
+
+	enter_ts = k_cycle_get_32();
+}
+
+void cpu_load_on_exit_idle(void)
+{
+	uint32_t now;
+
+	if (IS_ENABLED(CONFIG_CPU_LOAD_USE_COUNTER)) {
+		counter_get_value(counter, &now);
+	} else {
+		now = k_cycle_get_32();
+	}
+
+	ticks_idle += now - enter_ts;
+}
+
+int cpu_load_get(bool reset)
+{
+	uint32_t idle_us;
+	uint32_t total = k_cycle_get_32() - cyc_start;
+	uint32_t total_us = (uint32_t)k_cyc_to_us_floor32(total);
+	uint32_t res;
+	uint32_t active_us;
+
+	if (IS_ENABLED(CONFIG_CPU_LOAD_USE_COUNTER)) {
+		idle_us = counter_ticks_to_us(counter, ticks_idle);
+	} else {
+		idle_us = k_cyc_to_us_floor32(ticks_idle);
+	}
+
+	idle_us = MIN(idle_us, total_us);
+	active_us = total_us - idle_us;
+
+	res = ((1000 * active_us) / total_us);
+
+	if (reset) {
+		cyc_start = k_cycle_get_32();
+		ticks_idle = 0;
+	}
+
+	return res;
+}